1
=== modified file 'controllers/climate.py'
2
--- controllers/climate.py	2011-08-06 18:24:53 +0000
3
+++ controllers/climate.py	2011-09-05 13:55:13 +0000
4
@@ -2,92 +2,14 @@
5
2
2
6
3
module = "climate"
3
module = "climate"
7
4
4
94
5
class ClimateDataMapPlugin(object):
5
ClimateDataPortal = local_import("ClimateDataPortal")
95
6
    def __init__(self,
6
96
7
        data_type_option_names,
7
sample_type_names = ClimateDataPortal.sample_codes.keys()
97
8
        parameter_names,
8
variable_names = ClimateDataPortal.tables.keys()
98
9
        projected_option_type_names,
9
99
10
        year_min,
10
map_plugin = ClimateDataPortal.MapPlugin(
100
11
        year_max
11
    data_type_option_names = sample_type_names,
101
12
    ):
12
    parameter_names = variable_names,
16
13
        self.data_type_option_names = data_type_option_names
17
14
        self.parameter_names = parameter_names
18
15
        self.projected_option_type_names = projected_option_type_names
19
16
        self.year_min = year_min
20
17
        self.year_max = year_max
21
18
22
19
    def extend_gis_map(self, add_javascript, add_configuration):
23
20
        add_javascript("scripts/S3/s3.gis.climate.js")
24
21
        add_configuration(
25
22
            SCRIPT(
26
23
                "\n".join((
27
24
                    "registerPlugin(",
28
25
                    "    new ClimateDataMapPlugin("+
29
26
                            json.dumps(
30
27
                                dict(
31
28
                                    self.__dict__,
32
29
                                    data_type_label = str(T("Data Type")),
33
30
                                    projected_option_type_label = str(T("Projection Type"))
34
31
                                ),
35
32
                                indent = 4
36
33
                            )+
37
34
                    ")",
38
35
                    ")",
39
36
                ))
40
37
            )
41
38
        )
42
39
43
40
    def add_html(self, html):
44
41
        statistics_widget = FIELDSET(
45
42
            LEGEND("Statistics"),
46
43
            UL(
47
44
                _style="list-style:none",
48
45
                *(
49
46
                    LI(
50
47
                        INPUT(
51
48
                            _type="radio",
52
49
                            _name="statistics",
53
50
                            _id="id_%s" % statistic,
54
51
                        ),
55
52
                        LABEL(
56
53
                            statistic,
57
54
                            _for="id_%s" % statistic,
58
55
                        )
59
56
                    )
60
57
                    for statistic in ["Mean", "Max", "Min"]
61
58
                )
62
59
            )
63
60
        )
64
61
65
62
        html.append(
66
63
            DIV(
67
64
                FORM(
68
65
                    _id="controller",
69
66
                    *(
70
67
                        SCRIPT(
71
68
                            _type="text/javascript",
72
69
                            *["""
73
70
                            """]
74
71
                        ),
75
72
                        climate_data_type_widget,
76
73
                        parameters_widget,
77
74
                        statistics_widget,
78
75
                        period_widget
79
76
                    )
80
77
                )
81
78
            )
82
79
        )
83
80
84
81
    def get_image_overlay(self, ):
85
82
        from gluon.contenttype import contenttype
86
83
        response.headers["Content-Type"] = contenttype(".png")
87
84
        # @ToDo: Should be a file in static
88
85
        return response.stream(open("/Users/mike/Desktop/red_wave.png"))
89
86
90
87
climate_data_map_plugin = ClimateDataMapPlugin(
91
88
    data_type_option_names = ["Observed", "Gridded", "Projected"],
92
89
    parameter_names = ["Rainfall", "Temperature", "Wind", "Humidity", "Sunshine"],
93
90
    projected_option_type_names = ["RC Model", "GC Model", "Scenario"],
102
91
    year_max = datetime.date.today().year,
13
    year_max = datetime.date.today().year,
103
92
    year_min = 1960,
14
    year_min = 1960,
104
93
)
15
)
105
@@ -120,16 +42,16 @@
106
120
        print_tool = {"url": print_service}
42
        print_tool = {"url": print_service}
107
121
    else:
43
    else:
108
122
        print_tool = {}
44
        print_tool = {}
110
123
45
    
111
124
    map = gis.show_map(
46
    map = gis.show_map(
112
47
        lat = 28.5,
113
48
        lon = 84.1,
114
49
        zoom = 7,
115
125
        toolbar = False,
50
        toolbar = False,
117
126
        catalogue_toolbar=catalogue_toolbar, # T/F, top tabs toolbar
51
#        catalogue_toolbar=catalogue_toolbar, # T/F, top tabs toolbar
118
127
        wms_browser = wms_browser, # dict
52
        wms_browser = wms_browser, # dict
119
128
        catalogue_layers=catalogue_layers, # T/F
120
129
        mouse_position = deployment_settings.get_gis_mouse_position(),
121
130
        print_tool = print_tool,
122
131
        plugins = [
53
        plugins = [
124
132
            climate_data_map_plugin
54
            map_plugin
125
133
        ]
55
        ]
126
134
    )
56
    )
127
135
57
128
@@ -138,7 +60,148 @@
129
138
        module_name=module_name,
60
        module_name=module_name,
130
139
        map=map
61
        map=map
131
140
    )
62
    )
136
141
63
    
137
142
def climate_image_overlay():
64
month_names = dict(
138
143
    return climate_data_map_plugin.get_image_overlay()
65
    January=1,
139
144
66
    February=2,
140
67
    March=3,
141
68
    April=4,
142
69
    May=5,
143
70
    June=6,
144
71
    July=7,
145
72
    August=8,
146
73
    September=9,
147
74
    October=10,
148
75
    November=11,
149
76
    December=12
150
77
)
151
78
152
79
for name, number in month_names.items():
153
80
    month_names[name[:3]] = number
154
81
for name, number in month_names.items():
155
82
    month_names[name.upper()] = number
156
83
for name, number in month_names.items():
157
84
    month_names[name.lower()] = number
158
85
159
86
def convert_date(default_month):
160
87
    def converter(year_month):
161
88
        components = year_month.split("-")
162
89
        year = int(components[0])
163
90
        assert 1960 <= year, "year must be >= 1960"
164
91
        
165
92
        try:
166
93
            month_value = components[1]
167
94
        except IndexError:
168
95
            month = default_month
169
96
        else:
170
97
            try:
171
98
                month = int(month_value)
172
99
            except TypeError:
173
100
                month = month_names[month_value]
174
101
        
175
102
        assert 1 <= month <= 12, "month must be in range 1:12"
176
103
        return datetime.date(year, month, 1)
177
104
    return converter
178
105
179
106
def one_of(options):
180
107
    def validator(choice):
181
108
        assert choice in options, "should be one of %s, not '%s'" % (
182
109
            options,
183
110
            choice
184
111
        )
185
112
        return choice
186
113
    return validator
187
114
188
115
def climate_overlay_data():
189
116
    kwargs = dict(request.vars)
190
117
    kwargs["parameter"] = kwargs["parameter"].replace("+", " ")
191
118
    
192
119
    arguments = {}
193
120
    errors = []
194
121
    for kwarg_name, converter in dict(
195
122
        data_type = one_of(sample_type_names),
196
123
        statistic = one_of(("Maximum", "Minimum", "Average")),
197
124
        parameter = one_of(variable_names),
198
125
        from_date = convert_date(default_month = 1),
199
126
        to_date = convert_date(default_month = 12),
200
127
    ).iteritems():
201
128
        try:
202
129
            value = kwargs.pop(kwarg_name)
203
130
        except KeyError:
204
131
            errors.append("%s missing" % kwarg_name)
205
132
        else:
206
133
            try:
207
134
                arguments[kwarg_name] = converter(value)
208
135
            except TypeError:
209
136
                errors.append("%s is wrong type" % kwarg_name)
210
137
            except AssertionError, assertion_error:
211
138
                errors.append("%s: %s" % (kwarg_name, assertion_error))                
212
139
    if kwargs:
213
140
        errors.append("Unexpected arguments: %s" % kwargs.keys())
214
141
    
215
142
    if errors:
216
143
        raise HTTP(500, "<br />".join(errors))
217
144
    else:
218
145
        import gluon.contenttype
219
146
        data_path = map_plugin.get_overlay_data(
220
147
            env = Storage(globals()),
221
148
            **arguments
222
149
        )
223
150
        return response.stream(
224
151
            open(data_path,"rb"),
225
152
            chunk_size=4096
226
153
        )
227
154
228
155
def list_of(converter):
229
156
    def convert_list(choices):
230
157
        return map(converter, choices)
231
158
    return convert_list
232
159
233
160
def climate_chart():
234
161
    kwargs = dict(request.vars)
235
162
    import simplejson as JSON
236
163
    specs = JSON.loads(kwargs.pop("spec"))
237
164
    
238
165
    checked_specs = []
239
166
    for spec in specs:
240
167
        arguments = {}
241
168
        errors = []
242
169
        for name, converter in dict(
243
170
            data_type = one_of(sample_type_names),
244
171
            parameter = one_of(variable_names),
245
172
            from_date = convert_date(default_month = 1),
246
173
            to_date = convert_date(default_month = 12),
247
174
            place_ids = list_of(int)
248
175
        ).iteritems():
249
176
            try:
250
177
                value = spec.pop(name)
251
178
            except KeyError:
252
179
                errors.append("%s missing" % name)
253
180
            else:
254
181
                try:
255
182
                    arguments[name] = converter(value)
256
183
                except TypeError:
257
184
                    errors.append("%s is wrong type" % name)
258
185
                except AssertionError, assertion_error:
259
186
                    errors.append("%s: %s" % (name, assertion_error))
260
187
        if spec:
261
188
            errors.append("Unexpected arguments: %s" % spec.keys())
262
189
        checked_specs.append(arguments)
263
190
    
264
191
    if errors:
265
192
        raise HTTP(500, "<br />".join(errors))
266
193
    else:
267
194
        import gluon.contenttype
268
195
        response.headers["Content-Type"] = gluon.contenttype.contenttype(".png")
269
196
        data_image_file_path = map_plugin.render_plots(
270
197
            env = Storage(globals()),
271
198
            specs = checked_specs
272
199
        )
273
200
        return response.stream(
274
201
            open(data_image_file_path,"rb"),
275
202
            chunk_size=4096
276
203
        )
277
204
        
278
205
def chart_popup():
279
206
    return {}
280
207
    
281
145
208
282
=== modified file 'deployment-templates/models/000_config.py'
283
--- deployment-templates/models/000_config.py	2011-08-25 09:17:02 +0000
284
+++ deployment-templates/models/000_config.py	2011-09-05 13:55:13 +0000
285
@@ -249,7 +249,7 @@
286
249
    strict_hierarchy = False,
249
    strict_hierarchy = False,
287
250
    # Should all specific locations (e.g. addresses, waypoints) be required to
250
    # Should all specific locations (e.g. addresses, waypoints) be required to
288
251
    # link to where they are in the location hierarchy?
251
    # link to where they are in the location hierarchy?
290
252
    location_parent_required = False,
252
    location_parent_required = False
291
253
)
253
)
292
254
# Set this if there will be multiple areas in which work is being done,
254
# Set this if there will be multiple areas in which work is being done,
293
255
# and a menu to select among them is wanted. With this on, any map
255
# and a menu to select among them is wanted. With this on, any map
294
256
256
295
=== modified file 'models/03_gis.py'
296
--- models/03_gis.py	2011-08-26 08:12:56 +0000
297
+++ models/03_gis.py	2011-09-05 13:55:13 +0000
298
@@ -1369,6 +1369,8 @@
299
1369
# =============================================================================
1369
# =============================================================================
300
1370
def gis_map_tables():
1370
def gis_map_tables():
301
1371
    """ Load the GIS Map Tables when needed """
1371
    """ Load the GIS Map Tables when needed """
302
1372
    if "gis_layer_bing" in db.tables:
303
1373
        return
304
1372
1374
305
1373
    # -------------------------------------------------------------------------
1375
    # -------------------------------------------------------------------------
306
1374
    # GPS Waypoints
1376
    # GPS Waypoints
307
1375
1377
308
=== added file 'models/climate.py'
309
--- models/climate.py	1970-01-01 00:00:00 +0000
310
+++ models/climate.py	2011-09-05 13:55:13 +0000
311
@@ -0,0 +1,5 @@
312
1
# -*- coding: utf-8 -*-
313
2
314
3
module = "climate"
315
4
if deployment_settings.has_module(module):
316
5
    local_import("ClimateDataPortal").define_models(env = Storage(globals()))
317
0
6
318
=== added directory 'modules/ClimateDataPortal'
319
=== added file 'modules/ClimateDataPortal/MapPlugin.py'
320
--- modules/ClimateDataPortal/MapPlugin.py	1970-01-01 00:00:00 +0000
321
+++ modules/ClimateDataPortal/MapPlugin.py	2011-09-05 13:55:13 +0000
322
@@ -0,0 +1,430 @@
323
1
324
2
# notes:
325
3
326
4
# dependencies:
327
5
# R
328
6
329
7
# create folder for cache:
330
8
# mkdir -p /tmp/climate_data_portal/images/recent/
331
9
# mkdir -p /tmp/climate_data_portal/images/older/
332
10
333
11
MAX_CACHE_FOLDER_SIZE = 2**24 # 16 MiB
334
12
335
13
class TwoStageCache(object):
336
14
    def __init__(self, folder, max_size):
337
15
        self.folder = folder
338
16
        self.max_size
339
17
    
340
18
    def purge(self):
341
19
        pass
342
20
    
343
21
    def retrieve(self, file_name, generate_if_not_found):
344
22
        pass
345
23
346
24
import os, errno
347
25
348
26
def mkdir_p(path):
349
27
    try:
350
28
        os.makedirs(path)
351
29
    except OSError as exc: # Python >2.5
352
30
        if exc.errno == errno.EEXIST:
353
31
            pass
354
32
        else: raise
355
33
356
34
def define(env, place, tables, date_to_month_number, sample_codes, exports):
357
35
    # This starts an R interpreter.
358
36
    # As we are sharing it (restarting it every time is inefficient), 
359
37
    # we have to be somewhat careful to make sure objects are garbage collected
360
38
    # better to just not stick anything in R's globals 
361
39
    try:
362
40
        import rpy2.robjects as robjects
363
41
    except ImportError:
364
42
        import logging
365
43
        logging.getLogger().error(
366
44
"""R is required by the climate data portal to generate charts
367
45
368
46
To install R: refer to:
369
47
http://cran.r-project.org/doc/manuals/R-admin.html
370
48
371
49
372
50
rpy2 is required to interact with python.
373
51
374
52
To install rpy2, refer to:
375
53
http://rpy.sourceforge.net/rpy2/doc-dev/html/overview.html
376
54
""")
377
55
        raise
378
56
379
57
    R = robjects.r
380
58
    
381
59
    from rpy2.robjects.packages import importr
382
60
383
61
    base = importr("base")
384
62
    
385
63
    from math import fsum
386
64
    def average(values):
387
65
        "Safe float average"
388
66
        l = len(values)
389
67
        if l is 0:
390
68
            return None
391
69
        else:
392
70
            return fsum(values)/l
393
71
    
394
72
    class Maximum(object):
395
73
        def __init__(self, column, add_query_term):
396
74
            self.value_max = value_max = column.max()
397
75
            add_query_term(value_max)
398
76
            
399
77
        def __call__(self, row):
400
78
            return row._extra[self.value_max]
401
79
402
80
    class Minimum(object):
403
81
        def __init__(self, column, add_query_term):
404
82
            self.value_min = value_min = column.min()
405
83
            add_query_term(value_min)
406
84
            
407
85
        def __call__(self, row):
408
86
            return row._extra[self.value_min]    
409
87
410
88
    class Average(object):
411
89
        def __init__(self, column, add_query_term):
412
90
            self.value_sum = value_sum = column.sum()
413
91
            self.value_count = value_count = column.count()
414
92
            add_query_term((
415
93
                value_sum,
416
94
                value_count
417
95
            ))
418
96
            
419
97
        def __call__(self, row):
420
98
            return row._extra[self.value_sum] / row._extra[self.value_count]
421
99
422
100
    aggregators = {
423
101
        "Maximum": Maximum,
424
102
        "Minimum": Minimum,
425
103
        "Average": Average
426
104
    }
427
105
428
106
    def get_cached_or_generated_file(cache_file_name, generate):
429
107
        from os.path import join, exists
430
108
        from os import stat, makedirs
431
109
        # this needs to become a setting
432
110
        climate_data_image_cache_path = join(
433
111
            "/tmp","climate_data_portal","images"
434
112
        )
435
113
        recent_cache = join(climate_data_image_cache_path, "recent")
436
114
        mkdir_p(recent_cache)
437
115
        older_cache = join(climate_data_image_cache_path, "older")
438
116
        mkdir_p(older_cache)
439
117
        recent_cache_path = join(recent_cache, cache_file_name)
440
118
        if not exists(recent_cache_path):
441
119
            older_cache_path = join(older_cache, cache_file_name)
442
120
            if exists(older_cache_path):
443
121
                # move the older cache to the recent folder
444
122
                rename(older_cache_path, recent_cache_path)
445
123
            else:
446
124
                generate(recent_cache_path)
447
125
            file_path = recent_cache_path
448
126
                
449
127
            # update the folder size file (race condition?)
450
128
            folder_size_file_path = join(climate_data_image_cache_path, "size")
451
129
            folder_size_file = open(folder_size_file_path, "w+")
452
130
            folder_size_file_contents = folder_size_file.read()
453
131
            try:
454
132
                folder_size = int(folder_size_file_contents)
455
133
            except ValueError:
456
134
                folder_size = 0
457
135
            folder_size_file.seek(0)
458
136
            folder_size_file.truncate()
459
137
            folder_size += stat(file_path).st_size
460
138
            if folder_size > MAX_CACHE_FOLDER_SIZE:
461
139
                rmdir(older_cache)
462
140
463
141
            folder_size_file.write(str(folder_size))
464
142
            folder_size_file.close()
465
143
        else:
466
144
            # use the existing cached image
467
145
            file_path = recent_cache_path
468
146
        return file_path
469
147
470
148
    class MapPlugin(object):
471
149
        def __init__(
472
150
            self,
473
151
            data_type_option_names,
474
152
            parameter_names,
475
153
            year_min,
476
154
            year_max
477
155
        ):
478
156
            self.data_type_option_names = data_type_option_names
479
157
            self.parameter_names = parameter_names
480
158
            self.year_min = year_min 
481
159
            self.year_max = year_max
482
160
483
161
        def extend_gis_map(self, add_javascript, add_configuration):
484
162
            add_javascript("scripts/S3/s3.gis.climate.js")
485
163
            SCRIPT = env.SCRIPT
486
164
            T = env.T
487
165
            import json
488
166
            
489
167
            add_configuration(
490
168
                SCRIPT(
491
169
                    "\n".join((
492
170
                        "registerPlugin(",
493
171
                        "    new ClimateDataMapPlugin("+
494
172
                                json.dumps(
495
173
                                    dict(
496
174
                                        data_type_option_names = self.data_type_option_names,
497
175
                                        parameter_names = self.parameter_names,
498
176
                                        year_min = self.year_min,
499
177
                                        year_max = self.year_max,
500
178
                                        overlay_data_URL = "/%s/climate/climate_overlay_data" % (
501
179
                                            env.request.application
502
180
                                        ),
503
181
                                        chart_URL = "/%s/climate/climate_chart" % (
504
182
                                            env.request.application
505
183
                                        ),
506
184
                                        data_type_label = str(T("Data Type")),
507
185
                                        projected_option_type_label = str(
508
186
                                            T("Projection Type")
509
187
                                        )
510
188
                                    ),
511
189
                                    indent = 4
512
190
                                )+
513
191
                            ")",
514
192
                        ")",
515
193
                    ))
516
194
                )
517
195
            )
518
196
            
519
197
                
520
198
        def get_overlay_data(
521
199
            self,
522
200
            env,
523
201
            data_type,
524
202
            parameter,
525
203
            from_date,
526
204
            to_date,
527
205
            statistic
528
206
        ):            
529
207
            from_month = date_to_month_number(from_date)
530
208
            to_month = date_to_month_number(to_date)
531
209
            def generate_map_overlay_data(file_path):
532
210
                # generate the new file in the recent folder
533
211
                
534
212
                db = env.db
535
213
                sample_table_name, sample_table = tables[parameter]
536
214
                place = db.place
537
215
                #sample_table = db[sample_table_name]
538
216
                
539
217
                query = [
540
218
                    place.id,
541
219
                    place.longitude,
542
220
                    place.latitude,
543
221
                ]
544
222
                aggregator = aggregators[statistic](
545
223
                    sample_table.value,
546
224
                    query.append
547
225
                )
548
226
                
549
227
                sample_rows = db(
550
228
                    (sample_table.time_period >= from_month) &
551
229
                    (sample_table.time_period <= to_month) & 
552
230
                    (sample_table.sample_type == sample_codes[data_type]) & 
553
231
                    (place.id == sample_table.place_id)                
554
232
                ).select(
555
233
                    *query,
556
234
                    groupby=sample_table.place_id
557
235
                )
558
236
                
559
237
                # map positions to data
560
238
                # find max and min value
561
239
                positions = {}
562
240
                aggregated_values = []
563
241
                for row in sample_rows:
564
242
                    place = row.place
565
243
                    aggregated_value = aggregator(row)
566
244
                    aggregated_values.append(aggregated_value)
567
245
                    positions[place.id] = (
568
246
                        place.latitude,
569
247
                        place.longitude,
570
248
                        aggregated_value
571
249
                    ) 
572
250
                max_aggregated_value = max(aggregated_values)
573
251
                min_aggregated_value = min(aggregated_values)
574
252
                aggregated_range = max_aggregated_value - min_aggregated_value
575
253
                
576
254
                data_lines = []
577
255
                write = data_lines.append
578
256
                from colorsys import hsv_to_rgb
579
257
                for id, (lat, lon, aggregated_value) in positions.iteritems():
580
258
                    north = lat + 0.05
581
259
                    south = lat - 0.05
582
260
                    east = lon + 0.05
583
261
                    west = lon - 0.05
584
262
                    # only hue changes
585
263
                    # hue range is from 2/3 (blue, low) to 0 (red, high) 
586
264
                    normalised_value = 1.0-((aggregated_value - min_aggregated_value) / aggregated_range)
587
265
                    r,g,b = hsv_to_rgb(normalised_value *(2.0/3.0), 1.0, 1.0)
588
266
                    hex_colour = "%02x%02x%02x" % (r*255, g*255, b*255)
589
267
                    write(
590
268
                        "Vector("
591
269
                            "Polygon(["
592
270
                                "LinearRing(["
593
271
                                    "Point(%(north)f,%(west)f),"
594
272
                                    "Point(%(north)f,%(east)f),"
595
273
                                    "Point(%(south)f,%(east)f),"
596
274
                                    "Point(%(south)f,%(west)f)"
597
275
                                "])"
598
276
                            "]),"
599
277
                            "{"
600
278
                                "value:%(aggregated_value)f,"
601
279
                                "id:%(id)i"
602
280
                            "},"
603
281
                            "{"
604
282
                                "fillColor:'#%(hex_colour)s'"
605
283
                            "}"
606
284
                        ")," % locals()
607
285
                    )
608
286
                overlay_data_file = open(file_path, "w")
609
287
                write = overlay_data_file.write
610
288
                write("{")
611
289
                if max_aggregated_value < 10:
612
290
                    float_format = "%0.2f"
613
291
                if max_aggregated_value < 100:
614
292
                    float_format = "%0.1f"
615
293
                elif max_aggregated_value < 10000:
616
294
                    float_format = "%0.0f"
617
295
                else:
618
296
                    float_format = "%0.2e"
619
297
                write("max:%s," % float_format % max_aggregated_value)
620
298
                write("min:%s," % float_format % min_aggregated_value)
621
299
                write("features:[")
622
300
                write("".join(data_lines))
623
301
                overlay_data_file.seek(-1, 1) # delete last ",'
624
302
                write("]}")
625
303
                overlay_data_file.close()
626
304
                
627
305
            return get_cached_or_generated_file(
628
306
                "_".join((
629
307
                    statistic,
630
308
                    data_type,
631
309
                    parameter,
632
310
                    str(from_month),
633
311
                    str(to_month),
634
312
                    ".js"
635
313
                )),
636
314
                generate_map_overlay_data
637
315
            )
638
316
        
639
317
        def render_plots(
640
318
            self,
641
319
            env,
642
320
            specs
643
321
        ):
644
322
            def generate_chart(file_path):
645
323
                def render_plot(
646
324
                    data_type,
647
325
                    parameter,
648
326
                    from_date,
649
327
                    to_date,
650
328
                    place_ids
651
329
                ):
652
330
                    from_month = date_to_month_number(from_date)
653
331
                    to_month = date_to_month_number(to_date)
654
332
                    
655
333
                    db = env.db
656
334
                    sample_table_name, sample_table = tables[parameter]
657
335
                    place = db.place
658
336
                    #sample_table = db[sample_table_name]
659
337
                    sample_rows = db(
660
338
                        (sample_table.time_period >= from_month) &
661
339
                        (sample_table.time_period <= to_month) & 
662
340
                        (sample_table.sample_type == sample_codes[data_type]) & 
663
341
                        (sample_table.place_id.belongs(place_ids))
664
342
                    ).select(
665
343
                        sample_table.value,
666
344
                        sample_table.time_period,
667
345
                    )
668
346
                    
669
347
                    # coalesce values by time_period:
670
348
                    aggregated_values = {}
671
349
                    for sample_row in sample_rows:
672
350
                        time_period = sample_row.time_period
673
351
                        value = sample_row.value
674
352
                        try:
675
353
                            aggregated_values[time_period]
676
354
                        except KeyError:
677
355
                            aggregated_values[time_period] = value
678
356
                        else:
679
357
                            aggregated_values[time_period] += value
680
358
                    
681
359
                    values = []
682
360
                    time_periods = aggregated_values.keys()
683
361
                    time_periods.sort() 
684
362
                    for time_period in time_periods:
685
363
                        values.append(aggregated_values[time_period])                    
686
364
                    return from_date, to_date, data_type, parameter, values
687
365
688
366
                time_serieses = []
689
367
                c = R("c")
690
368
                for spec in specs:
691
369
                    from_date, to_date, data_type, parameter, values = render_plot(**spec)
692
370
                    time_serieses.append(
693
371
                        R("ts")(
694
372
                            robjects.FloatVector(values),
695
373
                            start = c(from_date.year, from_date.month),
696
374
                            end = c(to_date.year, to_date.month),
697
375
                            frequency = 12
698
376
                        )
699
377
                    )
700
378
                
701
379
                R("png(filename = '%s', width=640, height=480)" % file_path)
702
380
                plot_chart = R(
703
381
                    "function (xlab, ylab, n, ...) {"
704
382
                        "ts.plot(...,"
705
383
                            "gpars=list(xlab=xlab, ylab=ylab, col=c(1:n))"
706
384
                        ")"
707
385
                    "}"
708
386
                )
709
387
710
388
                plot_chart(
711
389
                    "Date",
712
390
                    "Combined %s %s" % (data_type, parameter),
713
391
                    len(time_serieses),
714
392
                    *time_serieses
715
393
                )
716
394
                R("dev.off()")
717
395
718
396
            import md5
719
397
            import gluon.contrib.simplejson as JSON
720
398
721
399
            import datetime
722
400
            def serialiseDate(obj):
723
401
                if isinstance(
724
402
                    obj,
725
403
                    (
726
404
                        datetime.date, 
727
405
                        datetime.datetime, 
728
406
                        datetime.time
729
407
                    )
730
408
                ): 
731
409
                    return obj.isoformat()[:19].replace("T"," ") 
732
410
                raise TypeError("%r is not JSON serializable" % (obj,)) 
733
411
            
734
412
            return get_cached_or_generated_file(
735
413
                "_".join((
736
414
                    md5.md5(
737
415
                        JSON.dumps(
738
416
                            specs,
739
417
                            sort_keys=True,
740
418
                            default=serialiseDate
741
419
                        )
742
420
                    ).hexdigest(),
743
421
                    ".png"
744
422
                )),
745
423
                generate_chart
746
424
            )
747
425
            
748
426
    exports.update(
749
427
        MapPlugin = MapPlugin
750
428
    )
751
429
    
752
430
    del globals()["define"]
753
0
431
754
=== added file 'modules/ClimateDataPortal/__init__.py'
755
--- modules/ClimateDataPortal/__init__.py	1970-01-01 00:00:00 +0000
756
+++ modules/ClimateDataPortal/__init__.py	2011-09-05 13:55:13 +0000
757
@@ -0,0 +1,201 @@
758
1
759
2
"""
760
3
    Climate Data Module
761
4
762
5
    @author: Mike Amy
763
6
"""
764
7
765
8
# datasets are stored in actual tables
766
9
#   - e.g. rainfall_mm
767
10
768
11
# data collection points in dataset
769
12
# values at a point within a time range
770
13
771
14
# e.g. observed temperature in Kathmandu between Feb 2006 - April 2007
772
15
773
16
774
17
sample_types = dict(
775
18
    O = "Observed",
776
19
    G = "Gridded",
777
20
    
778
21
    r = "Projected (RC)",
779
22
    g = "Projected (GC)",
780
23
    s = "Scenario",
781
24
)
782
25
783
26
sample_codes = {}
784
27
785
28
import re
786
29
for code, name in sample_types.iteritems():
787
30
    globals()[re.sub("\W", "", name)] = code
788
31
    sample_codes[name] = code
789
32
790
33
791
34
# Until I figure out how to sanely import things from web2py,
792
35
# apply a prophylactic import method...
793
36
def define_models(env):
794
37
    """
795
38
        Define Climate Data models.
796
39
    """    
797
40
    db = env.db
798
41
    Field = env.Field
799
42
800
43
    def create_index(table_name, field_name):
801
44
        db.executesql(
802
45
            """
803
46
            CREATE INDEX IF NOT EXISTS 
804
47
            "index_%(table_name)s__%(field_name)s" 
805
48
            ON "%(table_name)s" ("%(field_name)s");
806
49
            """ % locals()
807
50
        )
808
51
809
52
    place = db.define_table(
810
53
        "place",
811
54
        Field(
812
55
            "longitude",
813
56
            "double",
814
57
            notnull=True,
815
58
            required=True,
816
59
        ),
817
60
        Field(
818
61
            "latitude",
819
62
            "double",
820
63
            notnull=True,
821
64
            required=True,
822
65
        )
823
66
    )
824
67
825
68
    # not all places are stations with elevations
826
69
    # as in the case of "gridded" data
827
70
    # a station can only be in one place
828
71
    observation_station = db.define_table(
829
72
        "observation_station",
830
73
        Field(
831
74
            "id",
832
75
            "id", # must be a place,
833
76
            notnull=True,
834
77
            required=True,
835
78
        ),
836
79
        Field(
837
80
            "name",
838
81
            "string",
839
82
            notnull=True,
840
83
            unique=False,
841
84
            required=True,
842
85
        ),
843
86
        Field(
844
87
            "elevation_metres",
845
88
            "integer"
846
89
        )
847
90
    )
848
91
849
92
    def sample_table(name, value_type):
850
93
        table = db.define_table(
851
94
            name,
852
95
            Field(
853
96
                "sample_type",
854
97
                "string",
855
98
                length = 1,
856
99
                notnull=True,
857
100
                # necessary as web2py requires a default value even for 
858
101
                # not null fields                
859
102
                default="-1", 
860
103
                required=True
861
104
            ),
862
105
            Field(
863
106
                "time_period",
864
107
                "integer",
865
108
                notnull=True,
866
109
                default=-1000,
867
110
                required=True
868
111
            ),
869
112
            Field(
870
113
                # this should become a GIS field
871
114
                "place_id",
872
115
                place,
873
116
                notnull=True,
874
117
                required=True
875
118
            ),
876
119
            Field(
877
120
                "value",
878
121
                value_type,
879
122
                notnull = True,
880
123
                required=True,
881
124
            ),
882
125
        )
883
126
        
884
127
        create_index(name, "id")
885
128
        create_index(name, "sample_type")
886
129
        create_index(name, "time_period")
887
130
        create_index(name, "place_id")
888
131
889
132
        return table
890
133
891
134
    rainfall_mm = sample_table("climate_rainfall_mm", "double")
892
135
    min_temperature_celsius = sample_table("climate_min_temperature_celsius", "double")
893
136
    max_temperature_celsius = sample_table("climate_max_temperature_celsius", "double")
894
137
    
895
138
    tables = {
896
139
        "Rainfall mm": ("climate_rainfall_mm", rainfall_mm),
897
140
        "Max Temperature C": ("climate_max_temperature_celsius", max_temperature_celsius),
898
141
        "Min Temperature C": ("climate_min_temperature_celsius", min_temperature_celsius),
899
142
    }
900
143
    
901
144
    def year_month_to_month_number(year, month):
902
145
        """Time periods are integers representing months in years, 
903
146
        from 1960 onwards.
904
147
        
905
148
        e.g. 0 = Jan 1960, 1 = Feb 1960, 12 = Jan 1961
906
149
        
907
150
        This function converts a year and month to a month number.
908
151
        """
909
152
        return ((year-1960) * 12) + (month-1)
910
153
    
911
154
    def date_to_month_number(date):
912
155
        """This function converts a date to a month number.
913
156
        
914
157
        See also year_month_to_month_number(year, month)
915
158
        """
916
159
        return year_month_to_month_number(date.year, date.month)
917
160
    
918
161
#    def month_number_to_date(month_number):
919
162
#        ret
920
163
    
921
164
    from .MapPlugin import define 
922
165
    define(
923
166
        env,
924
167
        place,
925
168
        tables,
926
169
        date_to_month_number,
927
170
        sample_codes,
928
171
        globals()
929
172
    )
930
173
931
174
    # exports:
932
175
    globals().update(
933
176
        sample_types = sample_types,
934
177
        
935
178
        place = place,
936
179
        observation_station = observation_station,
937
180
        
938
181
        tables = tables,
939
182
        
940
183
        rainfall_mm = rainfall_mm,
941
184
        max_temperature_celsius = max_temperature_celsius,
942
185
        min_temperature_celsius = min_temperature_celsius,
943
186
    
944
187
        date_to_month_number = date_to_month_number,
945
188
        year_month_to_month_number = year_month_to_month_number,
946
189
    )
947
190
    
948
191
    def redefine_models(env):
949
192
        # avoid risking insidious aliasing bugs
950
193
        # by not defining things more than once 
951
194
        env.db.update(
952
195
            climate_rainfall_mm = rainfall_mm,
953
196
            climate_max_temperature_celsius = max_temperature_celsius,
954
197
            climate_min_temperature_celsius = min_temperature_celsius,
955
198
            place = place,
956
199
            observation_station = observation_station,
957
200
        )
958
201
    globals()["define_models"] = redefine_models
959
0
202
960
=== added file 'modules/ClimateDataPortal/import_NetCDF_readings.py'
961
--- modules/ClimateDataPortal/import_NetCDF_readings.py	1970-01-01 00:00:00 +0000
962
+++ modules/ClimateDataPortal/import_NetCDF_readings.py	2011-09-05 13:55:13 +0000
963
@@ -0,0 +1,131 @@
964
1
965
2
ClimateDataPortal = local_import("ClimateDataPortal")
966
3
967
4
968
5
def get_or_create(dict, key, creator):
969
6
    try:
970
7
        value = dict[key]
971
8
    except KeyError:
972
9
        value = dict[key] = creator()
973
10
    return value
974
11
975
12
def get_or_create_record(table, query):
976
13
    query_terms = []
977
14
    for key, value in query.iteritems():
978
15
        query_terms.append(getattr(table, key) == value)
979
16
    reduced_query = reduce(
980
17
        (lambda left, right: left & right),
981
18
        query_terms
982
19
    )
983
20
    records = db(reduced_query).select()
984
21
    count = len(records)
985
22
    assert count <= 1, "Multiple records for %s" % query
986
23
    if count == 0:
987
24
        record = table.insert(**query)
988
25
        db.commit()
989
26
    else:
990
27
        record = records.first()
991
28
    return record.id
992
29
993
30
def nearly(expected_float, actual_float):
994
31
    return (expected_float * 0.999) < actual_float < (expected_float * 1.001)
995
32
996
33
def add_reading_if_none(
997
34
    database_table,
998
35
    sample_type,
999
36
    time_period,
1000
37
    place_id,
1001
38
    value
1002
39
):
1003
40
    records = db(
1004
41
        (database_table.sample_type == sample_type) &
1005
42
        (database_table.time_period == time_period) &
1006
43
        (database_table.place_id == place_id)
1007
44
    ).select(database_table.value, database_table.id)
1008
45
    count = len(records)
1009
46
    assert count <= 1
1010
47
    if count == 0:
1011
48
        database_table.insert(
1012
49
            sample_type = sample_type,
1013
50
            time_period = time_period,
1014
51
            place_id = place_id,
1015
52
            value = value
1016
53
        )
1017
54
    else:
1018
55
        existing = records.first()
1019
56
        assert nearly(existing.value, value), (existing.value, value, place_id)
1020
57
1021
58
1022
59
1023
60
import datetime
1024
61
1025
62
def import_climate_readings(
1026
63
    netcdf_file,
1027
64
    database_table,
1028
65
    add_reading,
1029
66
    start_time = datetime.date(1971,1,1),
1030
67
    is_undefined = lambda x: -99.900003 < x < -99.9
1031
68
):
1032
69
    """
1033
70
    Assumptions:
1034
71
        * there are no places
1035
72
        * the data is in order of places
1036
73
    """
1037
74
    variables = netcdf_file.variables
1038
75
    
1039
76
    # create grid of places
1040
77
    place_ids = {}
1041
78
    
1042
79
    def to_list(variable):
1043
80
        result = []
1044
81
        for i in range(len(variable)):
1045
82
            result.append(variable[i])
1046
83
        return result
1047
84
    
1048
85
    def iter_pairs(list):
1049
86
        for index in range(len(list)):
1050
87
            yield index, list[index]
1051
88
    
1052
89
    times = to_list(variables["time"])
1053
90
    lat = to_list(variables["lat"])
1054
91
    lon = to_list(variables["lon"])
1055
92
    for latitude in lat:
1056
93
        for longitude in lon:
1057
94
            record = get_or_create_record(
1058
95
                ClimateDataPortal.place,
1059
96
                dict(
1060
97
                    longitude = longitude,
1061
98
                    latitude = latitude
1062
99
                )
1063
100
            )
1064
101
            place_ids[(latitude, longitude)] = record
1065
102
            #print longitude, latitude, record
1066
103
    
1067
104
    tt = variables["tt"]
1068
105
    print "up to:", len(times)
1069
106
    for time_index, time in iter_pairs(times):
1070
107
        print time_index
1071
108
        time_period = start_time+datetime.timedelta(hours=time)
1072
109
        for latitude_index, latitude in iter_pairs(lat):
1073
110
            for longitude_index, longitude in iter_pairs(lon):
1074
111
                value = tt[time_index][latitude_index][longitude_index]
1075
112
                if not is_undefined(value):
1076
113
                    add_reading(
1077
114
                        database_table = database_table,
1078
115
                        sample_type = ClimateDataPortal.Gridded,
1079
116
                        time_period = ClimateDataPortal.date_to_month_number(time_period),
1080
117
                        place_id = place_ids[(latitude, longitude)],
1081
118
                        value = value
1082
119
                    )
1083
120
    db.commit()
1084
121
1085
122
import sys
1086
123
1087
124
from Scientific.IO import NetCDF
1088
125
1089
126
file_name = sys.argv[1]
1090
127
import_climate_readings(
1091
128
    NetCDF.NetCDFFile(file_name),
1092
129
    ClimateDataPortal.min_temperature_celsius,
1093
130
    add_reading_if_none
1094
131
)
1095
0
132
1096
=== added file 'modules/ClimateDataPortal/import_stations.py'
1097
--- modules/ClimateDataPortal/import_stations.py	1970-01-01 00:00:00 +0000
1098
+++ modules/ClimateDataPortal/import_stations.py	2011-09-05 13:55:13 +0000
1099
@@ -0,0 +1,53 @@
1100
1
1101
2
ClimateDataPortal = local_import("ClimateDataPortal")
1102
3
1103
4
from decimal import Decimal
1104
5
1105
6
def import_stations(file_name):
1106
7
    """
1107
8
    Expects a file containing lines of the form e.g.:
1108
9
226     JALESORE             1122       172     26.65     85.78
1109
10
275     PHIDIM (PANCHTH      1419      1205     27.15     87.75
1110
11
unused  Station name         <-id    <-elev     <-lat     <-lon
1111
12
0123456789012345678901234567890123456789012345678901234567890123456789
1112
13
0         1         2         3         4         5         6
1113
14
    """
1114
15
    place = ClimateDataPortal.place
1115
16
    observation_station = ClimateDataPortal.observation_station
1116
17
    observation_station.truncate()
1117
18
    place.truncate()
1118
19
    db.commit()
1119
20
1120
21
    for line in open(file_name, "r").readlines():
1121
22
        try:
1122
23
            place_id_text = line[27:33]
1123
24
        except IndexError:
1124
25
            continue
1125
26
        else:            
1126
27
            try:
1127
28
                place_id = int(place_id_text)
1128
29
            except ValueError:
1129
30
                continue
1130
31
            else:
1131
32
                station_name = line[8:25].strip() # don't restrict if they add more
1132
33
                elevation_metres = int(line[37:43])
1133
34
                
1134
35
                latitude = Decimal(line[47:53])
1135
36
                longitude = Decimal(line[57:623])
1136
37
                
1137
38
                assert place.insert(
1138
39
                    id  = place_id,
1139
40
                    longitude = longitude,
1140
41
                    latitude = latitude
1141
42
                ) == place_id
1142
43
                
1143
44
                station_id = observation_station.insert(
1144
45
                    id = place_id,
1145
46
                    name = station_name,
1146
47
                    elevation_metres = elevation_metres
1147
48
                )
1148
49
                print place_id, station_name, latitude, longitude, elevation_metres 
1149
50
    db.commit()
1150
51
1151
52
import sys
1152
53
import_stations(sys.argv[1])
1153
0
54
1154
=== added file 'modules/ClimateDataPortal/import_tabbed_readings.py'
1155
--- modules/ClimateDataPortal/import_tabbed_readings.py	1970-01-01 00:00:00 +0000
1156
+++ modules/ClimateDataPortal/import_tabbed_readings.py	2011-09-05 13:55:13 +0000
1157
@@ -0,0 +1,154 @@
1158
1
1159
2
ClimateDataPortal = local_import("ClimateDataPortal")
1160
3
1161
4
from decimal import Decimal
1162
5
1163
6
1164
7
def get_or_create(dict, key, creator):
1165
8
    try:
1166
9
        value = dict[key]
1167
10
    except KeyError:
1168
11
        value = dict[key] = creator()
1169
12
    return value
1170
13
1171
14
import os
1172
15
1173
16
class Readings(object):
1174
17
    def __init__(
1175
18
        self,
1176
19
        database_table,
1177
20
        null_value,
1178
21
        maximum = None,
1179
22
        minimum = None
1180
23
    ):
1181
24
        self.database_table = database_table
1182
25
        db(database_table.sample_type == ClimateDataPortal.Observed).delete()
1183
26
        self.null_value = null_value
1184
27
        self.maximum = maximum
1185
28
        self.minimum = minimum
1186
29
        
1187
30
        self.aggregated_values = {}
1188
31
     
1189
32
    def add_reading(self, time_period, reading, out_of_range):
1190
33
        if reading != self.null_value:
1191
34
            if (
1192
35
                (self.minimum is not None and reading < self.minimum) or
1193
36
                (self.maximum is not None and reading > self.maximum)
1194
37
            ):
1195
38
                out_of_range(reading)
1196
39
            else:
1197
40
                readings = get_or_create(
1198
41
                    self.aggregated_values,
1199
42
                    time_period,
1200
43
                    list
1201
44
                )
1202
45
                readings.append(reading)
1203
46
1204
47
    def done(self, place_id):
1205
48
        for month_number, values in self.aggregated_values.iteritems():
1206
49
            self.database_table.insert(
1207
50
                sample_type = ClimateDataPortal.Observed,
1208
51
                time_period = month_number,
1209
52
                place_id = place_id,
1210
53
                value = sum(values) / len(values)
1211
54
            )
1212
55
1213
56
import datetime
1214
57
1215
58
1216
59
def import_tabbed_readings(
1217
60
    folder_name,
1218
61
    variables = [],
1219
62
    place_ids = None
1220
63
):
1221
64
    """
1222
65
    Expects a folder containing files with name rtXXXX.txt
1223
66
    
1224
67
    each file contains lines of the form e.g.:
1225
68
1978\t1\t1\t0\t-99.9\t-99.9
1226
69
1227
70
representing year, month, day, rainfall(mm), minimum and maximum temperature
1228
71
    """    
1229
72
    observation_station = ClimateDataPortal.observation_station
1230
73
    
1231
74
    null_value = Decimal("-99.9") # seems to be
1232
75
    
1233
76
    for row in db(observation_station).select(observation_station.id):
1234
77
        place_id = row.id
1235
78
        if place_ids is not None:
1236
79
            # avoid certain place ids (to allow importing particular places) 
1237
80
            start_place, end_place = map(int, place_ids.split(":"))
1238
81
            assert start_place <= end_place
1239
82
            if place_id < start_place or place_id > end_place:
1240
83
                continue
1241
84
        print place_id
1242
85
1243
86
        data_file_path = os.path.join(folder_name, "rt%04i.txt" % place_id)
1244
87
        if not os.path.exists(data_file_path):
1245
88
            print "%s not found" % data_file_path
1246
89
        else:
1247
90
            try:
1248
91
                for line in open(data_file_path, "r").readlines():
1249
92
                    if line:
1250
93
                        data = line.split()
1251
94
                        if data:
1252
95
                            try:
1253
96
                                year = int(data[0])
1254
97
                                month = int(data[1])
1255
98
                                day = int(data[2])
1256
99
                                
1257
100
                                time_period = ClimateDataPortal.year_month_to_month_number(year, month)
1258
101
                                
1259
102
                                for variable, reading_data in zip(
1260
103
                                    variables,
1261
104
                                    data[3:6]
1262
105
                                ):
1263
106
                                    def out_of_range(reading):
1264
107
                                        print "%s/%s/%s: %s out of range" % (
1265
108
                                            day, month, year, reading
1266
109
                                        )
1267
110
                                    reading = Decimal(reading_data)
1268
111
                                    variable.add_reading(
1269
112
                                        time_period,
1270
113
                                        reading,
1271
114
                                        out_of_range = out_of_range 
1272
115
                                    )
1273
116
                                
1274
117
                            except Exception, exception:
1275
118
                                print exception
1276
119
                for variable in variables:
1277
120
                    variable.done(place_id)
1278
121
            except:
1279
122
                print line
1280
123
                raise
1281
124
                
1282
125
        db.commit()
1283
126
    else:
1284
127
        print "No stations!"
1285
128
1286
129
import sys
1287
130
    
1288
131
null_value = Decimal("-99.9")
1289
132
import_tabbed_readings(
1290
133
    folder_name = sys.argv[1],
1291
134
    variables = [
1292
135
        Readings(
1293
136
            ClimateDataPortal.rainfall_mm,
1294
137
            null_value = null_value,
1295
138
            minimum = 0,
1296
139
        ),
1297
140
        Readings(
1298
141
            database_table = ClimateDataPortal.min_temperature_celsius,
1299
142
            null_value = null_value,
1300
143
            minimum = -120,
1301
144
            maximum = 55
1302
145
        ),
1303
146
        Readings(
1304
147
            database_table = ClimateDataPortal.max_temperature_celsius,
1305
148
            null_value = null_value,
1306
149
            minimum = -120,
1307
150
            maximum = 55
1308
151
        ),
1309
152
    ],
1310
153
    place_ids = sys.argv[2:] or None
1311
154
)
1312
0
155
1313
=== modified file 'modules/s3/s3gis.py'
1314
--- modules/s3/s3gis.py	2011-08-30 06:22:20 +0000
1315
+++ modules/s3/s3gis.py	2011-09-05 13:55:13 +0000
1316
@@ -74,16 +74,11 @@
1317
74
        Provide an easy, safe, systematic way of handling Debug output
74
        Provide an easy, safe, systematic way of handling Debug output
1318
75
        (print to stdout doesn't work with WSGI deployments)
75
        (print to stdout doesn't work with WSGI deployments)
1319
76
    """
76
    """
1330
77
    try:
77
    # should be using python's built-in logging module
1331
78
        output = "S3 Debug: %s" % str(message)
78
    output = u"S3 Debug: %s" % unicode(message)
1332
79
        if value:
79
    if value:
1333
80
            output += ": %s" % str(value)
80
        output += u": %s" % unicode(value)
1334
81
    except:
81
    sys.stderr.write(output)
1325
82
        output = "S3 Debug: %s" % unicode(message)
1326
83
        if value:
1327
84
            output += ": %s" % unicode(value)
1328
85
1329
86
    print >> sys.stderr, output
1335
87
82
1336
88
SHAPELY = False
83
SHAPELY = False
1337
89
try:
84
try:
1338
@@ -240,7 +235,6 @@
1339
240
    """
235
    """
1340
241
236
1341
242
    def __init__(self):
237
    def __init__(self):
1342
243
1343
244
        self.deployment_settings = current.deployment_settings
238
        self.deployment_settings = current.deployment_settings
1344
245
        self.public_url = current.deployment_settings.get_base_public_url()
239
        self.public_url = current.deployment_settings.get_base_public_url()
1345
246
        if not current.db is not None:
240
        if not current.db is not None:
1346
@@ -308,6 +302,18 @@
1347
308
        else:
302
        else:
1348
309
            return wkt
303
            return wkt
1349
310
304
1350
305
    def debug(self, message, value=None):
1351
306
        # should be using python's built-in logging module
1352
307
        session = current.session
1353
308
        if session.s3.debug:
1354
309
            raise Exception(message)
1355
310
        else:
1356
311
            output = u"S3 Debug: %s" % unicode(message)
1357
312
            if value:
1358
313
                output += u": %s" % unicode(value)
1359
314
            sys.stderr.write(output)
1360
315
            session.error = current.T(message)
1361
316
1362
311
    # -------------------------------------------------------------------------
317
    # -------------------------------------------------------------------------
1363
312
    def download_kml(self, record_id, filename):
318
    def download_kml(self, record_id, filename):
1364
313
        """
319
        """
1365
@@ -329,11 +335,11 @@
1366
329
        db = current.db
335
        db = current.db
1367
330
336
1368
331
        layer = KMLLayer(self)
337
        layer = KMLLayer(self)
1369
338
        
1370
332
        query = (layer.table.id == record_id)
339
        query = (layer.table.id == record_id)
1371
333
        record = db(query).select(limitby=(0, 1)).first()
340
        record = db(query).select(limitby=(0, 1)).first()
1372
334
        url = record.url
341
        url = record.url
1373
335
342
1374
336
        layer.add_record(record)
1375
337
        cachepath = layer.cachepath
343
        cachepath = layer.cachepath
1376
338
        filepath = os.path.join(cachepath, filename)
344
        filepath = os.path.join(cachepath, filename)
1377
339
345
1378
@@ -430,7 +436,7 @@
1379
430
                myfile = zipfile.ZipFile(fp)
436
                myfile = zipfile.ZipFile(fp)
1380
431
                try:
437
                try:
1381
432
                    file = myfile.read("doc.kml")
438
                    file = myfile.read("doc.kml")
1383
433
                except:
439
                except: # Naked except!!
1384
434
                    file = myfile.read(myfile.infolist()[0].filename)
440
                    file = myfile.read(myfile.infolist()[0].filename)
1385
435
                myfile.close()
441
                myfile.close()
1386
436
442
1387
@@ -534,7 +540,7 @@
1388
534
            try:
540
            try:
1389
535
                lon = features[0].lon
541
                lon = features[0].lon
1390
536
                simple = True
542
                simple = True
1392
537
            except:
543
            except AttributeError:
1393
538
                simple = False
544
                simple = False
1394
539
545
1395
540
            for feature in features:
546
            for feature in features:
1396
@@ -547,7 +553,7 @@
1397
547
                        # A Join
553
                        # A Join
1398
548
                        lon = feature.gis_location.lon
554
                        lon = feature.gis_location.lon
1399
549
                        lat = feature.gis_location.lat
555
                        lat = feature.gis_location.lat
1401
550
                except:
556
                except AttributeError:
1402
551
                    # Skip any rows without the necessary lat/lon fields
557
                    # Skip any rows without the necessary lat/lon fields
1403
552
                    continue
558
                    continue
1404
553
559
1405
@@ -988,7 +994,8 @@
1406
988
            _marker = db.gis_marker
994
            _marker = db.gis_marker
1407
989
            _projection = db.gis_projection
995
            _projection = db.gis_projection
1408
990
            have_tables = _config and _projection
996
            have_tables = _config and _projection
1410
991
        except:
997
        except Exception, exception:
1411
998
            self.debug(exception)
1412
992
            have_tables = False
999
            have_tables = False
1413
993
1000
1414
994
        row = None
1001
        row = None
1415
@@ -1005,16 +1012,13 @@
1416
1005
            if not row:
1012
            if not row:
1417
1006
                if auth.is_logged_in():
1013
                if auth.is_logged_in():
1418
1007
                    # Read personalised config, if available.
1014
                    # Read personalised config, if available.
1429
1008
                    try:
1015
                    query = (db.pr_person.uuid == auth.user.person_uuid) & \
1430
1009
                        query = (db.pr_person.uuid == auth.user.person_uuid) & \
1016
                            (_config.pe_id == db.pr_person.pe_id) & \
1431
1010
                                (_config.pe_id == db.pr_person.pe_id) & \
1017
                            (_marker.id == _config.marker_id) & \
1432
1011
                                (_marker.id == _config.marker_id) & \
1018
                            (_projection.id == _config.projection_id)
1433
1012
                                (_projection.id == _config.projection_id)
1019
                    row = db(query).select(limitby=(0, 1)).first()
1434
1013
                        row = db(query).select(limitby=(0, 1)).first()
1020
                    if row:
1435
1014
                        if row:
1021
                        config_id = row["gis_config"].id
1426
1015
                            config_id = row["gis_config"].id
1427
1016
                    except:
1428
1017
                        pass
1436
1018
                if not row:
1022
                if not row:
1437
1019
                    # No personal config or not logged in. Use site default.
1023
                    # No personal config or not logged in. Use site default.
1438
1020
                    config_id = 1
1024
                    config_id = 1
1439
@@ -1151,7 +1155,7 @@
1440
1151
        if level:
1155
        if level:
1441
1152
            try:
1156
            try:
1442
1153
                return location_hierarchy[level]
1157
                return location_hierarchy[level]
1444
1154
            except:
1158
            except KeyError:
1445
1155
                return level
1159
                return level
1446
1156
        else:
1160
        else:
1447
1157
            return location_hierarchy
1161
            return location_hierarchy
1448
@@ -1200,7 +1204,8 @@
1449
1200
        if level:
1204
        if level:
1450
1201
            try:
1205
            try:
1451
1202
                return all_levels[level]
1206
                return all_levels[level]
1453
1203
            except:
1207
            except Exception, exception:
1454
1208
                
1455
1204
                return level
1209
                return level
1456
1205
        else:
1210
        else:
1457
1206
            return all_levels
1211
            return all_levels
1458
@@ -1475,7 +1480,7 @@
1459
1475
                represent = db(table.id == value).select(table.name,
1480
                represent = db(table.id == value).select(table.name,
1460
1476
                                                         cache=cache,
1481
                                                         cache=cache,
1461
1477
                                                         limitby=(0, 1)).first().name
1482
                                                         limitby=(0, 1)).first().name
1463
1478
            except:
1483
            except: # @ToDo: provide specific exception
1464
1479
                # Keep the default from earlier
1484
                # Keep the default from earlier
1465
1480
                pass
1485
                pass
1466
1481
1486
1467
@@ -1515,24 +1520,21 @@
1468
1515
                    lat_max = location.lat_max
1520
                    lat_max = location.lat_max
1469
1516
1521
1470
1517
                else:
1522
                else:
1473
1518
                    s3_debug("Location searched within isn't a Polygon!")
1523
                    self.debug("Location searched within isn't a Polygon!")
1472
1519
                    session.error = T("Location searched within isn't a Polygon!")
1474
1520
                    return None
1524
                    return None
1476
1521
        except:
1525
        except: # @ToDo: need specific exception
1477
1522
            wkt = location
1526
            wkt = location
1478
1523
            if (wkt.startswith("POLYGON") or wkt.startswith("MULTIPOLYGON")):
1527
            if (wkt.startswith("POLYGON") or wkt.startswith("MULTIPOLYGON")):
1479
1524
                # ok
1528
                # ok
1480
1525
                lon_min = None
1529
                lon_min = None
1481
1526
            else:
1530
            else:
1484
1527
                s3_debug("This isn't a Polygon!")
1531
                self.debug("This isn't a Polygon!")
1483
1528
                session.error = T("This isn't a Polygon!")
1485
1529
                return None
1532
                return None
1486
1530
1533
1487
1531
        try:
1534
        try:
1488
1532
            polygon = wkt_loads(wkt)
1535
            polygon = wkt_loads(wkt)
1492
1533
        except:
1536
        except: # @ToDo: need specific exception
1493
1534
            s3_debug("Invalid Polygon!")
1537
            self.debug("Invalid Polygon!")
1491
1535
            session.error = T("Invalid Polygon!")
1494
1536
            return None
1538
            return None
1495
1537
1539
1496
1538
        table = db[tablename]
1540
        table = db[tablename]
1497
@@ -1540,8 +1542,7 @@
1498
1540
1542
1499
1541
        if "location_id" not in table.fields():
1543
        if "location_id" not in table.fields():
1500
1542
            # @ToDo: Add any special cases to be able to find the linked location
1544
            # @ToDo: Add any special cases to be able to find the linked location
1503
1543
            s3_debug("This table doesn't have a location_id!")
1545
            self.debug("This table doesn't have a location_id!")
1502
1544
            session.error = T("This table doesn't have a location_id!")
1504
1545
            return None
1546
            return None
1505
1546
1547
1506
1547
        query = (table.location_id == locations.id)
1548
        query = (table.location_id == locations.id)
1507
@@ -1573,7 +1574,10 @@
1508
1573
                        # Save Record
1574
                        # Save Record
1509
1574
                        output.records.append(row)
1575
                        output.records.append(row)
1510
1575
                except shapely.geos.ReadingError:
1576
                except shapely.geos.ReadingError:
1512
1576
                    s3_debug("Error reading wkt of location with id", row.id)
1577
                    self.debug(
1513
1578
                        "Error reading wkt of location with id",
1514
1579
                        value=row.id
1515
1580
                    )
1516
1577
        else:
1581
        else:
1517
1578
            # 1st check for Features included within the bbox (faster)
1582
            # 1st check for Features included within the bbox (faster)
1518
1579
            def in_bbox(row):
1583
            def in_bbox(row):
1519
@@ -1599,7 +1603,10 @@
1520
1599
                        # Save Record
1603
                        # Save Record
1521
1600
                        output.records.append(row)
1604
                        output.records.append(row)
1522
1601
                except shapely.geos.ReadingError:
1605
                except shapely.geos.ReadingError:
1524
1602
                    s3_debug("Error reading wkt of location with id", row.id)
1606
                    self.debug(
1525
1607
                        "Error reading wkt of location with id",
1526
1608
                        value = row.id,
1527
1609
                    )
1528
1603
1610
1529
1604
        return output
1611
        return output
1530
1605
1612
1531
@@ -2075,38 +2082,41 @@
1532
2075
            current_row += 1
2082
            current_row += 1
1533
2076
            try:
2083
            try:
1534
2077
                name0 = row.pop("ADM0_NAME")
2084
                name0 = row.pop("ADM0_NAME")
1536
2078
            except:
2085
            except KeyError:
1537
2079
                name0 = ""
2086
                name0 = ""
1538
2080
            try:
2087
            try:
1539
2081
                name1 = row.pop("ADM1_NAME")
2088
                name1 = row.pop("ADM1_NAME")
1541
2082
            except:
2089
            except KeyError:
1542
2083
                name1 = ""
2090
                name1 = ""
1543
2084
            try:
2091
            try:
1544
2085
                name2 = row.pop("ADM2_NAME")
2092
                name2 = row.pop("ADM2_NAME")
1546
2086
            except:
2093
            except KeyError:
1547
2087
                name2 = ""
2094
                name2 = ""
1548
2088
            try:
2095
            try:
1549
2089
                name3 = row.pop("ADM3_NAME")
2096
                name3 = row.pop("ADM3_NAME")
1551
2090
            except:
2097
            except KeyError:
1552
2091
                name3 = ""
2098
                name3 = ""
1553
2092
            try:
2099
            try:
1554
2093
                name4 = row.pop("ADM4_NAME")
2100
                name4 = row.pop("ADM4_NAME")
1556
2094
            except:
2101
            except KeyError:
1557
2095
                name4 = ""
2102
                name4 = ""
1558
2096
            try:
2103
            try:
1559
2097
                name5 = row.pop("ADM5_NAME")
2104
                name5 = row.pop("ADM5_NAME")
1561
2098
            except:
2105
            except KeyError:
1562
2099
                name5 = ""
2106
                name5 = ""
1563
2100
2107
1564
2101
            if not name5 and not name4 and not name3 and \
2108
            if not name5 and not name4 and not name3 and \
1565
2102
               not name2 and not name1:
2109
               not name2 and not name1:
1566
2103
                # We need a name! (L0's are already in DB)
2110
                # We need a name! (L0's are already in DB)
1568
2104
                s3_debug("No name provided", current_row)
2111
                self.debug(
1569
2112
                    "No name provided",
1570
2113
                    current_row,
1571
2114
                )
1572
2105
                continue
2115
                continue
1573
2106
2116
1574
2107
            try:
2117
            try:
1575
2108
                wkt = row.pop("WKT")
2118
                wkt = row.pop("WKT")
1577
2109
            except:
2119
            except KeyError:
1578
2110
                wkt = None
2120
                wkt = None
1579
2111
                try:
2121
                try:
1580
2112
                    lat = row.pop("LAT")
2122
                    lat = row.pop("LAT")
1581
@@ -2115,21 +2125,17 @@
1582
2115
                    lat = None
2125
                    lat = None
1583
2116
                    lon = None
2126
                    lon = None
1584
2117
2127
1591
2118
            if domain:
2128
            try:
1592
2119
                try:
2129
                uuid = row.pop("UUID")
1593
2120
                    uuid = "%s/%s" % (domain,
2130
            except KeyError:
1594
2121
                                      row.pop("UUID"))
2131
                uuid = ""
1589
2122
                except:
1590
2123
                    uuid = ""
1595
2124
            else:
2132
            else:
1600
2125
                try:
2133
                if domain:
1601
2126
                    uuid = row.pop("UUID")
2134
                    uuid = "%s/%s" % (domain, uuid)
1598
2127
                except:
1599
2128
                    uuid = ""
1602
2129
2135
1603
2130
            try:
2136
            try:
1604
2131
                code = row.pop("CODE")
2137
                code = row.pop("CODE")
1606
2132
            except:
2138
            except KeyError:
1607
2133
                code = ""
2139
                code = ""
1608
2134
2140
1609
2135
            population = ""
2141
            population = ""
1610
@@ -2175,7 +2181,7 @@
1611
2175
            # Calculate Centroid & Bounds
2181
            # Calculate Centroid & Bounds
1612
2176
            if wkt:
2182
            if wkt:
1613
2177
                try:
2183
                try:
1615
2178
                    # Valid WKT
2184
                        # Valid WKT
1616
2179
                    shape = wkt_loads(wkt)
2185
                    shape = wkt_loads(wkt)
1617
2180
                    centroid_point = shape.centroid
2186
                    centroid_point = shape.centroid
1618
2181
                    lon = centroid_point.x
2187
                    lon = centroid_point.x
1619
@@ -2189,8 +2195,8 @@
1620
2189
                        feature_type = 1 # Point
2195
                        feature_type = 1 # Point
1621
2190
                    else:
2196
                    else:
1622
2191
                        feature_type = 3 # Polygon
2197
                        feature_type = 3 # Polygon
1625
2192
                except:
2198
                except: # @ToDo: provide specific exception
1626
2193
                    s3_debug("Invalid WKT", name)
2199
                    self.debug("Invalid WKT", name)
1627
2194
                    continue
2200
                    continue
1628
2195
            else:
2201
            else:
1629
2196
                lon_min = lon_max = lon
2202
                lon_min = lon_max = lon
1630
@@ -2234,8 +2240,8 @@
1631
2234
                    else:
2240
                    else:
1632
2235
                        path += "%s/" % _parent.id
2241
                        path += "%s/" % _parent.id
1633
2236
                else:
2242
                else:
1636
2237
                    s3_debug("Location", name)
2243
                    self.debug("Location", name)
1637
2238
                    s3_debug("Parent cannot be found", parent)
2244
                    self.debug("Parent cannot be found", parent)
1638
2239
                    parent = ""
2245
                    parent = ""
1639
2240
2246
1640
2241
            # Check for duplicates
2247
            # Check for duplicates
1641
@@ -2245,8 +2251,8 @@
1642
2245
            duplicate = db(query).select(table.id, limitby=(0, 1)).first()
2251
            duplicate = db(query).select(table.id, limitby=(0, 1)).first()
1643
2246
2252
1644
2247
            if duplicate:
2253
            if duplicate:
1647
2248
                s3_debug("Location", name)
2254
                self.debug("Location", name)
1648
2249
                s3_debug("Duplicate - updating...")
2255
                self.debug("Duplicate - updating...")
1649
2250
                path += str(duplicate.id)
2256
                path += str(duplicate.id)
1650
2251
                # Update with any new information
2257
                # Update with any new information
1651
2252
                query = (table.id == duplicate.id)
2258
                query = (table.id == duplicate.id)
1652
@@ -2329,7 +2335,7 @@
1653
2329
        else:
2335
        else:
1654
2330
            cached = False
2336
            cached = False
1655
2331
            if not os.access(cachepath, os.W_OK):
2337
            if not os.access(cachepath, os.W_OK):
1657
2332
                s3_debug("Folder not writable", cachepath)
2338
                self.debug("Folder not writable", cachepath)
1658
2333
                return
2339
                return
1659
2334
2340
1660
2335
        if not cached:
2341
        if not cached:
1661
@@ -2338,11 +2344,11 @@
1662
2338
                f = fetch(url)
2344
                f = fetch(url)
1663
2339
            except (urllib2.URLError,):
2345
            except (urllib2.URLError,):
1664
2340
                e = sys.exc_info()[1]
2346
                e = sys.exc_info()[1]
1666
2341
                s3_debug("URL Error", e)
2347
                self.debug("URL Error", e)
1667
2342
                return
2348
                return
1668
2343
            except (urllib2.HTTPError,):
2349
            except (urllib2.HTTPError,):
1669
2344
                e = sys.exc_info()[1]
2350
                e = sys.exc_info()[1]
1671
2345
                s3_debug("HTTP Error", e)
2351
                self.debug("HTTP Error", e)
1672
2346
                return
2352
                return
1673
2347
2353
1674
2348
            # Unzip File
2354
            # Unzip File
1675
@@ -2355,8 +2361,8 @@
1676
2355
                    # For now, 2.5 users need to download/unzip manually to cache folder
2361
                    # For now, 2.5 users need to download/unzip manually to cache folder
1677
2356
                    myfile.extract(filename, cachepath)
2362
                    myfile.extract(filename, cachepath)
1678
2357
                    myfile.close()
2363
                    myfile.close()
1681
2358
                except:
2364
                except IOError:
1682
2359
                    s3_debug("Zipfile contents don't seem correct!")
2365
                    self.debug("Zipfile contents don't seem correct!")
1683
2360
                    myfile.close()
2366
                    myfile.close()
1684
2361
                    return
2367
                    return
1685
2362
2368
1686
@@ -2472,7 +2478,7 @@
1687
2472
                            # Should be just a single parent
2478
                            # Should be just a single parent
1688
2473
                            break
2479
                            break
1689
2474
                    except shapely.geos.ReadingError:
2480
                    except shapely.geos.ReadingError:
1691
2475
                        s3_debug("Error reading wkt of location with id", row.id)
2481
                        self.debug("Error reading wkt of location with id", row.id)
1692
2476
2482
1693
2477
                # Add entry to database
2483
                # Add entry to database
1694
2478
                table.insert(uuid=uuid,
2484
                table.insert(uuid=uuid,
1695
@@ -2492,7 +2498,7 @@
1696
2492
            else:
2498
            else:
1697
2493
                continue
2499
                continue
1698
2494
2500
1700
2495
        s3_debug("All done!")
2501
        self.debug("All done!")
1701
2496
        return
2502
        return
1702
2497
2503
1703
2498
    # -------------------------------------------------------------------------
2504
    # -------------------------------------------------------------------------
1704
@@ -2735,7 +2741,7 @@
1705
2735
2741
1706
2736
        db = current.db
2742
        db = current.db
1707
2737
        in_bbox = self.query_features_by_bbox(*shape.bounds)
2743
        in_bbox = self.query_features_by_bbox(*shape.bounds)
1709
2738
        has_wkt = (db.gis_location.wkt != None) & (db.gis_location.wkt != '')
2744
        has_wkt = (db.gis_location.wkt != None) & (db.gis_location.wkt != "")
1710
2739
2745
1711
2740
        for loc in db(in_bbox & has_wkt).select():
2746
        for loc in db(in_bbox & has_wkt).select():
1712
2741
            try:
2747
            try:
1713
@@ -2743,7 +2749,7 @@
1714
2743
                if location_shape.intersects(shape):
2749
                if location_shape.intersects(shape):
1715
2744
                    yield loc
2750
                    yield loc
1716
2745
            except shapely.geos.ReadingError:
2751
            except shapely.geos.ReadingError:
1718
2746
                s3_debug("Error reading wkt of location with id", loc.id)
2752
                self.debug("Error reading wkt of location with id", loc.id)
1719
2747
2753
1720
2748
    # -------------------------------------------------------------------------
2754
    # -------------------------------------------------------------------------
1721
2749
    def _get_features_by_latlon(self, lat, lon):
2755
    def _get_features_by_latlon(self, lat, lon):
1722
@@ -2799,7 +2805,7 @@
1723
2799
                try :
2805
                try :
1724
2800
                    shape = wkt_loads(location.wkt)
2806
                    shape = wkt_loads(location.wkt)
1725
2801
                except:
2807
                except:
1727
2802
                    s3_debug("Error reading WKT", location.wkt)
2808
                    self.debug("Error reading WKT", location.wkt)
1728
2803
                    continue
2809
                    continue
1729
2804
                bounds = shape.bounds
2810
                bounds = shape.bounds
1730
2805
                table[location.id] = dict(
2811
                table[location.id] = dict(
1731
@@ -2950,7 +2956,12 @@
1732
2950
            map_width = width
2956
            map_width = width
1733
2951
        else:
2957
        else:
1734
2952
            map_width = config.map_width
2958
            map_width = config.map_width
1736
2953
        if bbox and (-90 < bbox["max_lat"] < 90) and (-90 < bbox["min_lat"] < 90) and (-180 < bbox["max_lon"] < 180) and (-180 < bbox["min_lon"] < 180):
2959
        if (bbox 
1737
2960
            and (-90 < bbox["max_lat"] < 90) 
1738
2961
            and (-90 < bbox["min_lat"] < 90)
1739
2962
            and (-180 < bbox["max_lon"] < 180)
1740
2963
            and (-180 < bbox["min_lon"] < 180)
1741
2964
        ):
1742
2954
            # We have sane Bounds provided, so we should use them
2965
            # We have sane Bounds provided, so we should use them
1743
2955
            pass
2966
            pass
1744
2956
        else:
2967
        else:
1745
@@ -2974,15 +2985,21 @@
1746
2974
            projection = config.epsg
2985
            projection = config.epsg
1747
2975
2986
1748
2976
2987
1750
2977
        if projection != 900913 and projection != 4326:
2988
        if projection not in (900913, 4326):
1751
2978
            # Test for Valid Projection file in Proj4JS library
2989
            # Test for Valid Projection file in Proj4JS library
1753
2979
            projpath = os.path.join(request.folder, "static", "scripts", "gis", "proj4js", "lib", "defs", "EPSG%s.js" % projection)
2990
            projpath = os.path.join(
1754
2991
                request.folder, "static", "scripts", "gis", "proj4js", \
1755
2992
                "lib", "defs", "EPSG%s.js" % projection
1756
2993
            )
1757
2980
            try:
2994
            try:
1758
2981
                f = open(projpath, "r")
2995
                f = open(projpath, "r")
1759
2982
                f.close()
2996
                f.close()
1760
2983
            except:
2997
            except:
1763
2984
                session.error = "%s /static/scripts/gis/proj4js/lib/defs" % T("Projection not supported - please add definition to")
2998
                session.error = "'%s' %s /static/scripts/gis/proj4js/lib/defs" % (
1764
2985
                redirect(URL(c="gis", f="projection"))
2999
                    projection,
1765
3000
                    T("Projection not supported - please add definition to")
1766
3001
                )
1767
3002
                redirect(URL(r=request, c="gis", f="projection"))
1768
2986
3003
1769
2987
        units = config.units
3004
        units = config.units
1770
2988
        maxResolution = config.maxResolution
3005
        maxResolution = config.maxResolution
1771
@@ -3055,11 +3072,12 @@
1772
3055
        #########
3072
        #########
1773
3056
        # Scripts
3073
        # Scripts
1774
3057
        #########
3074
        #########
1775
3075
        
1776
3058
        def add_javascript(script):
3076
        def add_javascript(script):
1777
3059
            if type(script) == SCRIPT:
3077
            if type(script) == SCRIPT:
1778
3060
                html.append(script)
3078
                html.append(script)
1779
3061
            elif script.startswith("http"):
3079
            elif script.startswith("http"):
1781
3062
                 html.append(
3080
                html.append(
1782
3063
                    SCRIPT(_type="text/javascript",
3081
                    SCRIPT(_type="text/javascript",
1783
3064
                           _src=script))
3082
                           _src=script))
1784
3065
            else:
3083
            else:
1785
@@ -3069,7 +3087,7 @@
1786
3069
3087
1787
3070
        debug = session.s3.debug
3088
        debug = session.s3.debug
1788
3071
        if debug:
3089
        if debug:
1790
3072
            if projection != 900913 and projection != 4326:
3090
            if projection not in (900913, 4326):
1791
3073
                add_javascript("scripts/gis/proj4js/lib/proj4js-combined.js")
3091
                add_javascript("scripts/gis/proj4js/lib/proj4js-combined.js")
1792
3074
                add_javascript("scripts/gis/proj4js/lib/defs/EPSG%s.js" % projection)
3092
                add_javascript("scripts/gis/proj4js/lib/defs/EPSG%s.js" % projection)
1793
3075
3093
1794
@@ -3082,7 +3100,7 @@
1795
3082
                add_javascript("scripts/gis/usng2.js")
3100
                add_javascript("scripts/gis/usng2.js")
1796
3083
                add_javascript("scripts/gis/MP.js")
3101
                add_javascript("scripts/gis/MP.js")
1797
3084
        else:
3102
        else:
1799
3085
            if projection != 900913 and projection != 4326:
3103
            if projection not in (900913, 4326):
1800
3086
                add_javascript("scripts/gis/proj4js/lib/proj4js-compressed.js")
3104
                add_javascript("scripts/gis/proj4js/lib/proj4js-compressed.js")
1801
3087
                add_javascript("scripts/gis/proj4js/lib/defs/EPSG%s.js" % projection)
3105
                add_javascript("scripts/gis/proj4js/lib/defs/EPSG%s.js" % projection)
1802
3088
            add_javascript("scripts/gis/OpenLayers.js")
3106
            add_javascript("scripts/gis/OpenLayers.js")
1803
@@ -3184,20 +3202,20 @@
1804
3184
        # If we do come back to it, then it should be moved to static
3202
        # If we do come back to it, then it should be moved to static
1805
3185
        if print_tool:
3203
        if print_tool:
1806
3186
            url = print_tool["url"]
3204
            url = print_tool["url"]
1808
3187
            url+'' # check url can be concatenated with strings
3205
            url+"" # check url can be concatenated with strings
1809
3188
            if "title" in print_tool:
3206
            if "title" in print_tool:
1811
3189
                mapTitle = str(print_tool["mapTitle"])
3207
                mapTitle = unicode(print_tool["mapTitle"])
1812
3190
            else:
3208
            else:
1814
3191
                mapTitle = str(T("Map from Sahana Eden"))
3209
                mapTitle = unicode(T("Map from Sahana Eden"))
1815
3192
            if "subtitle" in print_tool:
3210
            if "subtitle" in print_tool:
1817
3193
                subTitle = str(print_tool["subTitle"])
3211
                subTitle = unicode(print_tool["subTitle"])
1818
3194
            else:
3212
            else:
1820
3195
                subTitle = str(T("Printed from Sahana Eden"))
3213
                subTitle = unicode(T("Printed from Sahana Eden"))
1821
3196
            if session.auth:
3214
            if session.auth:
1823
3197
                creator = session.auth.user.email
3215
                creator = unicode(session.auth.user.email)
1824
3198
            else:
3216
            else:
1825
3199
                creator = ""
3217
                creator = ""
1827
3200
            print_tool1 = "".join(("""
3218
            print_tool1 = u"".join(("""
1828
3201
        if (typeof(printCapabilities) != 'undefined') {
3219
        if (typeof(printCapabilities) != 'undefined') {
1829
3202
            // info.json from script headers OK
3220
            // info.json from script headers OK
1830
3203
            printProvider = new GeoExt.data.PrintProvider({
3221
            printProvider = new GeoExt.data.PrintProvider({
1831
@@ -3221,7 +3239,7 @@
1832
3221
            //    printProvider: printProvider
3239
            //    printProvider: printProvider
1833
3222
            //});
3240
            //});
1834
3223
            // A layer to display the print page extent
3241
            // A layer to display the print page extent
1836
3224
            //var pageLayer = new OpenLayers.Layer.Vector('""", str(T("Print Extent")), """');
3242
            //var pageLayer = new OpenLayers.Layer.Vector('""", unicode(T("Print Extent")), """');
1837
3225
            //pageLayer.addFeatures(printPage.feature);
3243
            //pageLayer.addFeatures(printPage.feature);
1838
3226
            //pageLayer.setVisibility(false);
3244
            //pageLayer.setVisibility(false);
1839
3227
            //map.addLayer(pageLayer);
3245
            //map.addLayer(pageLayer);
1840
@@ -3237,7 +3255,7 @@
1841
3237
            //});
3255
            //});
1842
3238
            // The form with fields controlling the print output
3256
            // The form with fields controlling the print output
1843
3239
            S3.gis.printFormPanel = new Ext.form.FormPanel({
3257
            S3.gis.printFormPanel = new Ext.form.FormPanel({
1845
3240
                title: '""", str(T("Print Map")), """',
3258
                title: '""", unicode(T("Print Map")), """',
1846
3241
                rootVisible: false,
3259
                rootVisible: false,
1847
3242
                split: true,
3260
                split: true,
1848
3243
                autoScroll: true,
3261
                autoScroll: true,
1849
@@ -3250,7 +3268,7 @@
1850
3250
                defaults: {anchor: '100%%'},
3268
                defaults: {anchor: '100%%'},
1851
3251
                listeners: {
3269
                listeners: {
1852
3252
                    'expand': function() {
3270
                    'expand': function() {
1854
3253
                        //if (null == mapPanel.map.getLayersByName('""", str(T("Print Extent")), """')[0]) {
3271
                        //if (null == mapPanel.map.getLayersByName('""", unicode(T("Print Extent")), """')[0]) {
1855
3254
                        //    mapPanel.map.addLayer(pageLayer);
3272
                        //    mapPanel.map.addLayer(pageLayer);
1856
3255
                        //}
3273
                        //}
1857
3256
                        if (null == mapPanel.plugins[0]) {
3274
                        if (null == mapPanel.plugins[0]) {
1858
@@ -3278,7 +3296,7 @@
1859
3278
                    xtype: 'textarea',
3296
                    xtype: 'textarea',
1860
3279
                    name: 'comment',
3297
                    name: 'comment',
1861
3280
                    value: '',
3298
                    value: '',
1863
3281
                    fieldLabel: '""", str(T("Comment")), """',
3299
                    fieldLabel: '""", unicode(T("Comment")), """',
1864
3282
                    plugins: new GeoExt.plugins.PrintPageField({
3300
                    plugins: new GeoExt.plugins.PrintPageField({
1865
3283
                        printPage: printPage
3301
                        printPage: printPage
1866
3284
                    })
3302
                    })
1867
@@ -3286,7 +3304,7 @@
1868
3286
                    xtype: 'combo',
3304
                    xtype: 'combo',
1869
3287
                    store: printProvider.layouts,
3305
                    store: printProvider.layouts,
1870
3288
                    displayField: 'name',
3306
                    displayField: 'name',
1872
3289
                    fieldLabel: '""", str(T("Layout")), """',
3307
                    fieldLabel: '""", T("Layout").decode("utf-8"), """',
1873
3290
                    typeAhead: true,
3308
                    typeAhead: true,
1874
3291
                    mode: 'local',
3309
                    mode: 'local',
1875
3292
                    triggerAction: 'all',
3310
                    triggerAction: 'all',
1876
@@ -3297,7 +3315,7 @@
1877
3297
                    xtype: 'combo',
3315
                    xtype: 'combo',
1878
3298
                    store: printProvider.dpis,
3316
                    store: printProvider.dpis,
1879
3299
                    displayField: 'name',
3317
                    displayField: 'name',
1881
3300
                    fieldLabel: '""", str(T("Resolution")), """',
3318
                    fieldLabel: '""", unicode(T("Resolution")), """',
1882
3301
                    tpl: '<tpl for="."><div class="x-combo-list-item">{name} dpi</div></tpl>',
3319
                    tpl: '<tpl for="."><div class="x-combo-list-item">{name} dpi</div></tpl>',
1883
3302
                    typeAhead: true,
3320
                    typeAhead: true,
1884
3303
                    mode: 'local',
3321
                    mode: 'local',
1885
@@ -3314,7 +3332,7 @@
1886
3314
                //    xtype: 'combo',
3332
                //    xtype: 'combo',
1887
3315
                //    store: printProvider.scales,
3333
                //    store: printProvider.scales,
1888
3316
                //    displayField: 'name',
3334
                //    displayField: 'name',
1890
3317
                //    fieldLabel: '""", str(T("Scale")), """',
3335
                //    fieldLabel: '""", unicode(T("Scale")), """',
1891
3318
                //    typeAhead: true,
3336
                //    typeAhead: true,
1892
3319
                //    mode: 'local',
3337
                //    mode: 'local',
1893
3320
                //    triggerAction: 'all',
3338
                //    triggerAction: 'all',
1894
@@ -3324,13 +3342,13 @@
1895
3324
                //}, {
3342
                //}, {
1896
3325
                //    xtype: 'textfield',
3343
                //    xtype: 'textfield',
1897
3326
                //    name: 'rotation',
3344
                //    name: 'rotation',
1899
3327
                //    fieldLabel: '""", str(T("Rotation")), """',
3345
                //    fieldLabel: '""", unicode(T("Rotation")), """',
1900
3328
                //    plugins: new GeoExt.plugins.PrintPageField({
3346
                //    plugins: new GeoExt.plugins.PrintPageField({
1901
3329
                //        printPage: printPage
3347
                //        printPage: printPage
1902
3330
                //    })
3348
                //    })
1903
3331
                }],
3349
                }],
1904
3332
                buttons: [{
3350
                buttons: [{
1906
3333
                    text: '""", str(T("Create PDF")), """',
3351
                    text: '""", unicode(T("Create PDF")), """',
1907
3334
                    handler: function() {
3352
                    handler: function() {
1908
3335
                        // the PrintExtent plugin is the mapPanel's 1st plugin
3353
                        // the PrintExtent plugin is the mapPanel's 1st plugin
1909
3336
                        //mapPanel.plugins[0].print();
3354
                        //mapPanel.plugins[0].print();
1910
@@ -3348,7 +3366,7 @@
1911
3348
        } else {
3366
        } else {
1912
3349
            // Display error diagnostic
3367
            // Display error diagnostic
1913
3350
            S3.gis.printFormPanel = new Ext.Panel ({
3368
            S3.gis.printFormPanel = new Ext.Panel ({
1915
3351
                title: '""", str(T("Print Map")), """',
3369
                title: '""", unicode(T("Print Map")), """',
1916
3352
                rootVisible: false,
3370
                rootVisible: false,
1917
3353
                split: true,
3371
                split: true,
1918
3354
                autoScroll: true,
3372
                autoScroll: true,
1919
@@ -3359,7 +3377,7 @@
1920
3359
                bodyStyle: 'padding:5px',
3377
                bodyStyle: 'padding:5px',
1921
3360
                labelAlign: 'top',
3378
                labelAlign: 'top',
1922
3361
                defaults: {anchor: '100%'},
3379
                defaults: {anchor: '100%'},
1924
3362
                html: '""", str(T("Printing disabled since server not accessible")), """: <BR />""", url, """'
3380
                html: '""", unicode(T("Printing disabled since server not accessible")), """: <BR />""", unicode(url), """'
1925
3363
            });
3381
            });
1926
3364
        }
3382
        }
1927
3365
        """))
3383
        """))
1928
@@ -3445,40 +3463,40 @@
1929
3445
            name_safe = re.sub("'", "", layer.name)
3463
            name_safe = re.sub("'", "", layer.name)
1930
3446
            if layer.url2:
3464
            if layer.url2:
1931
3447
                url2 = """,
3465
                url2 = """,
1933
3448
    url2: '%s'""" % layer.url2
3466
    "url2": "%s\"""" % layer.url2
1934
3449
            else:
3467
            else:
1935
3450
                url2 = ""
3468
                url2 = ""
1936
3451
            if layer.url3:
3469
            if layer.url3:
1937
3452
                url3 = """,
3470
                url3 = """,
1939
3453
    url3: '%s'""" % layer.url3
3471
    "url3": "%s\"""" % layer.url3
1940
3454
            else:
3472
            else:
1941
3455
                url3 = ""
3473
                url3 = ""
1942
3456
            if layer.base:
3474
            if layer.base:
1943
3457
                base = ""
3475
                base = ""
1944
3458
            else:
3476
            else:
1945
3459
                base = """,
3477
                base = """,
1947
3460
    isBaseLayer: false"""
3478
    "isBaseLayer": false"""
1948
3461
            if layer.visible:
3479
            if layer.visible:
1949
3462
                visibility = ""
3480
                visibility = ""
1950
3463
            else:
3481
            else:
1951
3464
                visibility = """,
3482
                visibility = """,
1953
3465
    visibility: false"""
3483
    "visibility": false"""
1954
3466
            if layer.attribution:
3484
            if layer.attribution:
1955
3467
                attribution = """,
3485
                attribution = """,
1957
3468
    attribution: '%s'""" % layer.attribution
3486
    "attribution": %s""" % repr(layer.attribution)
1958
3469
            else:
3487
            else:
1959
3470
                attribution = ""
3488
                attribution = ""
1960
3471
            if layer.zoom_levels is not None and layer.zoom_levels != 19:
3489
            if layer.zoom_levels is not None and layer.zoom_levels != 19:
1961
3472
                zoomLevels = """,
3490
                zoomLevels = """,
1963
3473
    zoomLevels: %i""" % layer.zoom_levels
3491
    "zoomLevels": %i""" % layer.zoom_levels
1964
3474
            else:
3492
            else:
1965
3475
                zoomLevels = ""
3493
                zoomLevels = ""
1966
3476
3494
1967
3477
            # Generate JS snippet to pass to static
3495
            # Generate JS snippet to pass to static
1968
3478
            layers_osm += """
3496
            layers_osm += """
1969
3479
S3.gis.layers_osm[%i] = {
3497
S3.gis.layers_osm[%i] = {
1972
3480
    name: '%s',
3498
    "name": "%s",
1973
3481
    url1: '%s'%s%s%s%s%s%s
3499
    "url1": "%s"%s%s%s%s%s%s
1974
3482
}
3500
}
1975
3483
""" % (counter,
3501
""" % (counter,
1976
3484
       name_safe,
3502
       name_safe,
1977
@@ -3490,6 +3508,7 @@
1978
3490
       attribution,
3508
       attribution,
1979
3491
       zoomLevels)
3509
       zoomLevels)
1980
3492
3510
1981
3511
1982
3493
        # ---------------------------------------------------------------------
3512
        # ---------------------------------------------------------------------
1983
3494
        # XYZ
3513
        # XYZ
1984
3495
        # @ToDo: Migrate to Class/Static
3514
        # @ToDo: Migrate to Class/Static
1985
@@ -3681,7 +3700,7 @@
1986
3681
3700
1987
3682
            if "active" in layer and not layer["active"]:
3701
            if "active" in layer and not layer["active"]:
1988
3683
                visibility = """,
3702
                visibility = """,
1990
3684
    visibility: false"""
3703
    "visibility": false"""
1991
3685
            else:
3704
            else:
1992
3686
                visibility = ""
3705
                visibility = ""
1993
3687
3706
1994
@@ -3712,32 +3731,33 @@
1995
3712
                        marker_url = ""
3731
                        marker_url = ""
1996
3713
                if marker_url:
3732
                if marker_url:
1997
3714
                    markerLayer = """,
3733
                    markerLayer = """,
2001
3715
    marker_url: '%s',
3734
    "marker_url": "%s",
2002
3716
    marker_height: %i,
3735
    "marker_height": %i,
2003
3717
    marker_width: %i""" % (marker_url, marker_height, marker_width)
3736
    "marker_width": %i""" % (marker_url, marker_height, marker_width)
2004
3718
3737
2005
3719
            if "opacity" in layer and layer["opacity"] != 1:
3738
            if "opacity" in layer and layer["opacity"] != 1:
2006
3720
                opacity = """,
3739
                opacity = """,
2008
3721
    opacity: %.1f""" % layer["opacity"]
3740
    "opacity": %.1f""" % layer["opacity"]
2009
3722
            else:
3741
            else:
2010
3723
                opacity = ""
3742
                opacity = ""
2011
3724
            if "cluster_distance" in layer and layer["cluster_distance"] != self.cluster_distance:
3743
            if "cluster_distance" in layer and layer["cluster_distance"] != self.cluster_distance:
2012
3725
                cluster_distance = """,
3744
                cluster_distance = """,
2014
3726
    cluster_distance: %i""" % layer["cluster_distance"]
3745
    "cluster_distance": %i""" % layer["cluster_distance"]
2015
3727
            else:
3746
            else:
2016
3728
                cluster_distance = ""
3747
                cluster_distance = ""
2017
3729
            if "cluster_threshold" in layer and layer["cluster_threshold"] != self.cluster_threshold:
3748
            if "cluster_threshold" in layer and layer["cluster_threshold"] != self.cluster_threshold:
2018
3730
                cluster_threshold = """,
3749
                cluster_threshold = """,
2020
3731
    cluster_threshold: %i""" % layer["cluster_threshold"]
3750
    "cluster_threshold": %i""" % layer["cluster_threshold"]
2021
3732
            else:
3751
            else:
2022
3733
                cluster_threshold = ""
3752
                cluster_threshold = ""
2023
3734
3753
2024
3735
            # Generate JS snippet to pass to static
3754
            # Generate JS snippet to pass to static
2025
3736
            layers_feature_queries += """
3755
            layers_feature_queries += """
2026
3737
S3.gis.layers_feature_queries[%i] = {
3756
S3.gis.layers_feature_queries[%i] = {
2030
3738
    name: '%s',
3757
    "name": "%s",
2031
3739
    url: '%s'%s%s%s%s%s
3758
    "url": "%s"%s%s%s%s%s
2032
3740
}""" % (counter,
3759
}
2033
3760
""" % (counter,
2034
3741
        name,
3761
        name,
2035
3742
        url,
3762
        url,
2036
3743
        visibility,
3763
        visibility,
2037
@@ -3745,36 +3765,44 @@
2038
3745
        opacity,
3765
        opacity,
2039
3746
        cluster_distance,
3766
        cluster_distance,
2040
3747
        cluster_threshold)
3767
        cluster_threshold)
2042
3748
3768
        
2043
3749
        # ---------------------------------------------------------------------
3769
        # ---------------------------------------------------------------------
2044
3750
        # Add Layers from the Catalogue
3770
        # Add Layers from the Catalogue
2045
3751
        # ---------------------------------------------------------------------
3771
        # ---------------------------------------------------------------------
2046
3752
        layers_config = ""
3772
        layers_config = ""
2047
3753
        if catalogue_layers:
3773
        if catalogue_layers:
2048
3754
            for LayerType in [
3774
            for LayerType in [
2072
3755
                    #OSMLayer,
3775
                #OSMLayer,
2073
3756
                    Bing,
3776
                BingLayer,
2074
3757
                    Google,
3777
                GoogleLayer,
2075
3758
                    Yahoo,
3778
                YahooLayer,
2076
3759
                    TMSLayer,
3779
                TMSLayer,
2077
3760
                    WMSLayer,
3780
                WMSLayer,
2078
3761
                    FeatureLayer,
3781
                FeatureLayer,
2079
3762
                    GeoJSONLayer,
3782
                GeoJSONLayer,
2080
3763
                    GeoRSSLayer,
3783
                GeoRSSLayer,
2081
3764
                    GPXLayer,
3784
                GPXLayer,
2082
3765
                    KMLLayer,
3785
                KMLLayer,
2083
3766
                    WFSLayer
3786
                WFSLayer
2084
3767
                ]:
3787
            ]:
2085
3768
                # Instantiate the Class
3788
                try:
2086
3769
                layer = LayerType(self)
3789
                    # Instantiate the Class
2087
3770
                layer_type_js = layer.as_javascript()
3790
                    layer = LayerType(self)
2088
3771
                if layer_type_js:
3791
                    layer_type_js = layer.as_javascript()
2089
3772
                    # Add to the output JS
3792
                    if layer_type_js:
2090
3773
                    layers_config = "".join((layers_config,
3793
                        # Add to the output JS
2091
3774
                                             layer_type_js))
3794
                        layers_config = "".join((layers_config,
2092
3775
                    if layer.scripts:
3795
                                                 layer_type_js))
2093
3776
                        for script in layer.scripts:
3796
                        if layer.scripts:
2094
3777
                            add_javascript(script)
3797
                            for script in layer.scripts:
2095
3798
                                add_javascript(script)
2096
3799
                except Exception, exception:
2097
3800
                    if debug:
2098
3801
                        raise
2099
3802
                    else:
2100
3803
                        session.warning.append(
2101
3804
                            LayerType.__name__ + " not shown due to error"
2102
3805
                        )                
2103
3778
3806
2104
3779
            # -----------------------------------------------------------------
3807
            # -----------------------------------------------------------------
2105
3780
            # Coordinate Grid - only one possible
3808
            # Coordinate Grid - only one possible
2106
@@ -3848,6 +3876,7 @@
2107
3848
            "S3.gis.marker_default_width = %i;\n" % marker_default.width,
3876
            "S3.gis.marker_default_width = %i;\n" % marker_default.width,
2108
3849
            osm_auth,
3877
            osm_auth,
2109
3850
            layers_osm,
3878
            layers_osm,
2110
3879
            layers_feature_queries,
2111
3851
            _features,
3880
            _features,
2112
3852
            layers_config,
3881
            layers_config,
2113
3853
            # i18n Labels
3882
            # i18n Labels
2114
@@ -3880,6 +3909,7 @@
2115
3880
        ))))
3909
        ))))
2116
3881
3910
2117
3882
        # Static Script
3911
        # Static Script
2118
3912
2119
3883
        if debug:
3913
        if debug:
2120
3884
            add_javascript("scripts/S3/s3.gis.js")
3914
            add_javascript("scripts/S3/s3.gis.js")
2121
3885
            add_javascript("scripts/S3/s3.gis.layers.js")
3915
            add_javascript("scripts/S3/s3.gis.layers.js")
2122
@@ -3889,7 +3919,6 @@
2123
3889
3919
2124
3890
        # Dynamic Script (stuff which should, as far as possible, be moved to static)
3920
        # Dynamic Script (stuff which should, as far as possible, be moved to static)
2125
3891
        html.append(SCRIPT(layers_js + \
3921
        html.append(SCRIPT(layers_js + \
2126
3892
                           #layers_xyz + \
2127
3893
                           print_tool1))
3922
                           print_tool1))
2128
3894
3923
2129
3895
        # Set up map plugins
3924
        # Set up map plugins
2130
@@ -3904,8 +3933,7 @@
2131
3904
3933
2132
3905
        return html
3934
        return html
2133
3906
3935
2136
3907
3936
# -----------------------------------------------------------------------------
2135
3908
# =============================================================================
2137
3909
class Marker(object):
3937
class Marker(object):
2138
3910
    """ Represents a Map Marker """
3938
    """ Represents a Map Marker """
2139
3911
    def __init__(self, gis, id=None):
3939
    def __init__(self, gis, id=None):
2140
@@ -3938,6 +3966,13 @@
2141
3938
        #self.url = URL(c="static", f="img",
3966
        #self.url = URL(c="static", f="img",
2142
3939
        #               args=["markers", marker.image])
3967
        #               args=["markers", marker.image])
2143
3940
3968
2144
3969
    def add_attributes_to_output(self, output):
2145
3970
        output.update(
2146
3971
            marker_image = self.image,
2147
3972
            marker_height = self.height,
2148
3973
            marker_width = self.width,
2149
3974
        )
2150
3975
        
2151
3941
# -----------------------------------------------------------------------------
3976
# -----------------------------------------------------------------------------
2152
3942
class Projection(object):
3977
class Projection(object):
2153
3943
    """ Represents a Map Projection """
3978
    """ Represents a Map Projection """
2154
@@ -3963,41 +3998,34 @@
2155
3963
        self.epsg = projection.epsg
3998
        self.epsg = projection.epsg
2156
3964
3999
2157
3965
# -----------------------------------------------------------------------------
4000
# -----------------------------------------------------------------------------
2158
4001
2159
4002
def config_dict(mandatory, defaulted):
2160
4003
    d = dict(mandatory)
2161
4004
    for key, (value, defaults) in defaulted.iteritems():
2162
4005
        if value not in defaults:
2163
4006
            d[key] = value
2164
4007
    return d
2165
4008
2166
4009
2167
4010
# the layer code only needs to do:
2168
4011
# any database lookups to get extra data
2169
4012
# security checks.
2170
4013
2171
4014
# then it generates appropriate JSON strings.
2172
4015
2173
3966
class Layer(object):
4016
class Layer(object):
2174
3967
    """
4017
    """
2177
3968
        Base Class for Layers
4018
        Abstract Base Class for Layers
2176
3969
            Not meant to be instantiated direct
2178
3970
    """
4019
    """
2180
3971
    def __init__(self, gis, record=None):
4020
    def __init__(self, gis):
2181
4021
        self.gis = gis
2182
3972
        db = current.db
4022
        db = current.db
2211
3973
4023
        try:
2212
3974
        self.gis = gis
4024
            self.table = db[self.table_name]
2213
3975
        # This usually arrives later
4025
        except:
2214
3976
        self.record = record
4026
            current.manager.load(self.table_name)
2215
3977
        # Ensure all attributes available (even if Null)
4027
            self.table = db[tablename]
2216
3978
        self._refresh()
4028
2189
3979
        self.scripts = []
2190
3980
2191
3981
    def add_record(self, record):
2192
3982
        """
2193
3983
            Update the record & refresh the attributes
2194
3984
        """
2195
3985
        if record:
2196
3986
            self.record = record
2197
3987
            self._refresh()
2198
3988
        else:
2199
3989
            return
2200
3990
2201
3991
    def as_dict(self):
2202
3992
        """
2203
3993
            Output the Layer as a Python dictionary
2204
3994
            - this is used to build a JSON of the overall dict of layers
2205
3995
        """
2206
3996
        record = self.record
2207
3997
        if record:
2208
3998
            return record
2209
3999
        else:
2210
4000
            return
2217
4001
4029
2218
4002
    def as_json(self):
4030
    def as_json(self):
2219
4003
        """
4031
        """
2220
@@ -4009,663 +4037,480 @@
2221
4009
        else:
4037
        else:
2222
4010
            return
4038
            return
2223
4011
4039
2380
4012
    def as_javascript(self):
4040
2381
4013
        """
4041
2382
4014
            Output the Layer as Javascript
4042
# -----------------------------------------------------------------------------
2383
4015
            - suitable for inclusion in the HTML page
4043
class SingleRecordLayer(Layer):
2384
4016
        """
4044
    """
2385
4017
        gis = self.gis
4045
        Abstract Base Class for Layers with just a single record
2386
4018
        auth = gis.auth
4046
    """
2387
4019
        db = current.db
4047
    
2388
4020
        table = self.table
4048
    def __init__(self, gis):
2389
4021
4049
        super(SingleRecordLayer, self).__init__(gis)
2390
4022
        layer_type_list = []
4050
        table = self.table
2391
4023
        # Read the enabled Layers
4051
        records = current.db(table.id > 0).select()
2392
4024
        records = db(table.enabled == True).select()
4052
        assert len(records) <= 1, (
2393
4025
        for record in records:
4053
            "There should only ever be 0 or 1 %s" % self.__class__.__name__
2394
4026
            # Check user is allowed to access the layer
4054
        )
2395
4027
            role_required = record.role_required
4055
        self.record = None
2396
4028
            if (not role_required) or auth.s3_has_role(role_required):
4056
        record = records.first()
2397
4029
                # Pass the record to the Class
4057
        if record is not None:
2398
4030
                self.add_record(record)
4058
            if record.enabled:
2399
4031
                # Read the output dict for this layer
4059
                role_required = record.role_required
2400
4032
                layer_dict = self.as_dict()
4060
                if not role_required or self.gis.auth.s3_has_role(role_required):
2401
4033
                if layer_dict:
4061
                    self.record = record
2402
4034
                    # Add this layer to the list of layers for this layer type
4062
            # Refresh the attributes of the Layer
2403
4035
                    layer_type_list.append(layer_dict)
4063
            if "apikey" in table:
2404
4036
4064
                if record:
2405
4037
        if layer_type_list:
4065
                    self.apikey = record.apikey
2406
4038
            # Output the Layer Type as JSON
4066
                else:
2407
4039
            layer_type_json = json.dumps(layer_type_list,
4067
                    self.apikey = None
2408
4040
                                         sort_keys=True,
4068
        self.gis = gis
2409
4041
                                         indent=4)
4069
        self.scripts = []
2410
4042
            layer_type_js = "".join(("%s = " % self.js_array,
4070
2411
4043
                                     layer_type_json,
4071
    def as_javascript(self):
2412
4044
                                     "\n"))
4072
        """
2413
4045
            return layer_type_js
4073
            Output the Layer as Javascript
2414
4046
4074
            - suitable for inclusion in the HTML page
2415
4047
    def _name_safe(self, name):
4075
        """
2416
4048
        """
4076
        if self.record:
2417
4049
            Make the name safe for use in JSON
4077
            if "apikey" in self.table and not self.apikey:
2418
4050
            i.e. any Unicode character allowed except for " & \
4078
                raise Exception("Cannot display a %s if we have no valid API Key" % self.__class__.__name__)
2419
4051
        """
4079
            json = self.as_json()
2420
4052
        return re.sub('[\\"]', "", name)
4080
            if json:
2421
4053
4081
                return "%s = %s\n" % (
2422
4054
    def _refresh(self):
4082
                    self.js_array,
2423
4055
        " Refresh the attributes of the Layer "
4083
                    json
2424
4056
        table = self.table
4084
                )
2425
4057
        if "marker_id" in table:
4085
            else:
2426
4058
            self.set_marker()
4086
                return None
2427
4059
        if "projection_id" in table:
4087
        else:
2428
4060
            self.set_projection()
4088
            return None
2429
4061
4089
2430
4062
    def set_marker(self):
4090
# -----------------------------------------------------------------------------
2431
4063
        " Set the Marker for the Layer "
4091
class BingLayer(SingleRecordLayer):
2432
4064
        gis = self.gis
4092
    """ Bing Layer from Catalogue """
2433
4065
        record = self.record
4093
    table_name = "gis_layer_bing"
2434
4066
        if record:
4094
    js_array = "S3.gis.Bing"
2435
4067
            marker = Marker(gis, record.marker_id)
4095
    
2280
4068
            self.marker = marker
2281
4069
        else:
2282
4070
            self.marker = None
2283
4071
2284
4072
    def set_projection(self):
2285
4073
        " Set the Projection for the Layer "
2286
4074
        gis = self.gis
2287
4075
        record = self.record
2288
4076
        if record:
2289
4077
            projection = Projection(gis, record.projection_id)
2290
4078
            self.projection = projection
2291
4079
        else:
2292
4080
            self.projection = None
2293
4081
2294
4082
# -----------------------------------------------------------------------------
2295
4083
class OneLayer(Layer):
2296
4084
    """
2297
4085
        Base Class for Layers with just a single record
2298
4086
            Not meant to be instantiated direct
2299
4087
    """
2300
4088
2301
4089
    def __init__(self, gis, record=None):
2302
4090
        db = current.db
2303
4091
        tablename = ""
2304
4092
        try:
2305
4093
            table = db[tablename]
2306
4094
        except:
2307
4095
            current.manager.load(tablename)
2308
4096
            table = db[tablename]
2309
4097
        if not record:
2310
4098
            # There is only ever 1 layer
2311
4099
            record = db(table.id > 0).select().first()
2312
4100
2313
4101
        self.gis = gis
2314
4102
        self.table = table
2315
4103
        self.js_array = "S3.gis.OneLayer"
2316
4104
        self.record = record
2317
4105
        self._refresh()
2318
4106
        self.scripts = []
2319
4107
2320
4108
    def as_javascript(self):
2321
4109
        """
2322
4110
            Output the Layer as Javascript
2323
4111
            - suitable for inclusion in the HTML page
2324
4112
        """
2325
4113
        auth = self.gis.auth
2326
4114
        record = self.record
2327
4115
        # Check Layer exists in the DB
2328
4116
        if not record:
2329
4117
            return None
2330
4118
        # Check Layer is enabled
2331
4119
        if not record.enabled:
2332
4120
            return None
2333
4121
        # Check user is allowed to access the Layer
2334
4122
        role_required = record.role_required
2335
4123
        if role_required and not auth.s3_has_role(role_required):
2336
4124
            return None
2337
4125
        # Read the output JSON for this layer
2338
4126
        layer_type_json = self.as_json()
2339
4127
        layer_type_js = "".join(("%s = " % self.js_array,
2340
4128
                                 layer_type_json,
2341
4129
                                 "\n"))
2342
4130
        return layer_type_js
2343
4131
2344
4132
    def _set_api_key(self):
2345
4133
        " Set the API Key for the Layer "
2346
4134
        record = self.record
2347
4135
        if record:
2348
4136
            self.apikey = record.apikey
2349
4137
        else:
2350
4138
            self.apikey = None
2351
4139
2352
4140
    def _refresh(self):
2353
4141
        " Refresh the attributes of the Layer "
2354
4142
        table = self.table
2355
4143
        if "apikey" in table:
2356
4144
            self._set_api_key()
2357
4145
2358
4146
# -----------------------------------------------------------------------------
2359
4147
class Bing(OneLayer):
2360
4148
    """ Bing Layers from Catalogue """
2361
4149
    def __init__(self, gis, record=None):
2362
4150
        db = current.db
2363
4151
        tablename = "gis_layer_bing"
2364
4152
        try:
2365
4153
            table = db[tablename]
2366
4154
        except:
2367
4155
            current.manager.load(tablename)
2368
4156
            table = db[tablename]
2369
4157
        if not record:
2370
4158
            # There is only ever 1 layer
2371
4159
            record = db(table.id > 0).select().first()
2372
4160
2373
4161
        self.gis = gis
2374
4162
        self.table = table
2375
4163
        self.js_array = "S3.gis.Bing"
2376
4164
        self.record = record
2377
4165
        self._refresh()
2378
4166
        self.scripts = []
2379
4167
2436
4168
    def as_dict(self):
4096
    def as_dict(self):
2437
4169
        gis = self.gis
4097
        gis = self.gis
2438
4170
        record = self.record
4098
        record = self.record
2465
4171
        apikey = self.apikey
4099
        if record is not None:
2466
4172
4100
            config = self.gis.get_config()
2467
4173
        if not apikey:
4101
            if Projection(gis, id=config.projection_id).epsg != 900913:
2468
4174
            # Cannot display Bing layers if we have no valid API Key
4102
                raise Exception("Cannot display Bing layers unless we're using the Spherical Mercator Projection")
2469
4175
            return None
4103
            else:
2470
4176
4104
                # Mandatory attributes
2471
4177
        config = gis.get_config()
4105
                output = {
2472
4178
        if Projection(gis, id=config.projection_id).epsg != 900913:
4106
                    "ApiKey": self.apikey
2473
4179
            # Cannot display Bing layers unless we're using the
4107
                    }
2474
4180
            # Spherical Mercator Projection
4108
2475
4181
            return None
4109
                # Attributes which are defaulted client-side if not set
2476
4182
4110
                if record.aerial_enabled:
2477
4183
        # Mandatory attributes
4111
                    output["Aerial"] = record.aerial or "Bing Satellite"
2478
4184
        output = {
4112
                if record.road_enabled:
2479
4185
                "ApiKey": self.apikey
4113
                    output["Road"] = record.road or "Bing Roads"
2480
4186
            }
4114
                if record.hybrid_enabled:
2481
4187
4115
                    output["Hybrid"] = record.hybrid or "Bing Hybrid"
2482
4188
        # Attributes which are defaulted client-side if not set
4116
                return output
2483
4189
        if record.aerial_enabled:
4117
        else:
2484
4190
            output["Aerial"] = record.aerial or "Bing Satellite"
4118
            return None
2459
4191
        if record.road_enabled:
2460
4192
            output["Road"] = record.road or "Bing Roads"
2461
4193
        if record.hybrid_enabled:
2462
4194
            output["Hybrid"] = record.hybrid or "Bing Hybrid"
2463
4195
2464
4196
        return output
2485
4197
4119
2486
4198
# -----------------------------------------------------------------------------
4120
# -----------------------------------------------------------------------------
2488
4199
class Google(OneLayer):
4121
class GoogleLayer(SingleRecordLayer):
2489
4200
    """
4122
    """
2490
4201
        Google Layers/Tools from Catalogue
4123
        Google Layers/Tools from Catalogue
2491
4202
    """
4124
    """
2512
4203
    def __init__(self, gis, record=None):
4125
    table_name = "gis_layer_google"
2513
4204
        db = current.db
4126
    js_array = "S3.gis.Google"
2514
4205
        tablename = "gis_layer_google"
4127
    
2515
4206
        try:
4128
    def __init__(self, gis):
2516
4207
            table = db[tablename]
4129
        super(GoogleLayer, self).__init__(gis)
2517
4208
        except:
4130
        record = self.record
2518
4209
            current.manager.load(tablename)
4131
        if record is not None:
2519
4210
            table = db[tablename]
4132
            debug = current.session.s3.debug
2520
4211
        debug = current.session.s3.debug
4133
            add_script = self.scripts.append
2501
4212
        if not record:
2502
4213
            # There is only ever 1 layer
2503
4214
            record = db(table.id > 0).select().first()
2504
4215
2505
4216
        self.gis = gis
2506
4217
        self.table = table
2507
4218
        self.js_array = "S3.gis.Google"
2508
4219
        self.record = record
2509
4220
        self._refresh()
2510
4221
2511
4222
        if record:
2521
4223
            if record.mapmaker_enabled or record.mapmakerhybrid_enabled:
4134
            if record.mapmaker_enabled or record.mapmakerhybrid_enabled:
2522
4224
                # Need to use v2 API
4135
                # Need to use v2 API
2523
4225
                # http://code.google.com/p/gmaps-api-issues/issues/detail?id=2349
4136
                # http://code.google.com/p/gmaps-api-issues/issues/detail?id=2349
2525
4226
                self.scripts = ["http://maps.google.com/maps?file=api&v=2&key=%s" % self.apikey]
4137
                add_script("http://maps.google.com/maps?file=api&v=2&key=%s" % self.apikey)
2526
4227
            else:
4138
            else:
2527
4228
                # v3 API
4139
                # v3 API
2529
4229
                self.scripts = ["http://maps.google.com/maps/api/js?v=3.2&sensor=false"]
4140
                add_script("http://maps.google.com/maps/api/js?v=3.2&sensor=false")
2530
4230
                if debug and record.streetview_enabled:
4141
                if debug and record.streetview_enabled:
2532
4231
                    self.scripts.append("scripts/gis/gxp/widgets/GoogleStreetViewPanel.js")
4142
                    add_script("scripts/gis/gxp/widgets/GoogleStreetViewPanel.js")
2533
4232
            if record.earth_enabled:
4143
            if record.earth_enabled:
2536
4233
                self.scripts.append("http://www.google.com/jsapi?key=%s" % self.apikey)
4144
                add_script("http://www.google.com/jsapi?key=%s" % self.apikey)
2537
4234
                self.scripts.append(SCRIPT("google && google.load('earth', '1');", _type="text/javascript"))
4145
                add_script(SCRIPT("google && google.load('earth', '1');", _type="text/javascript"))
2538
4235
                if debug:
4146
                if debug:
2542
4236
                    self.scripts.append("scripts/gis/gxp/widgets/GoogleEarthPanel.js")
4147
                    add_script("scripts/gis/gxp/widgets/GoogleEarthPanel.js")
2540
4237
        else:
2541
4238
            self.scripts = []
2543
4239
4148
2544
4240
    def as_dict(self):
4149
    def as_dict(self):
2545
4241
        gis = self.gis
4150
        gis = self.gis
2546
4242
        T = current.T
4151
        T = current.T
2547
4243
        record = self.record
4152
        record = self.record
2552
4244
        apikey = self.apikey
4153
        if record is not None:
2553
4245
4154
            config = gis.get_config()
2554
4246
        if not apikey and (record.mapmaker_enabled or record.mapmakerhybrid_enabled):
4155
            if Projection(gis, id=config.projection_id).epsg != 900913:
2555
4247
            # Cannot display Google layers if we have no valid API Key
4156
                if record.earth_enabled:
2556
4157
                    # But the Google Earth panel can still be enabled
2557
4158
                    return {
2558
4159
                        "Earth": str(T("Switch to 3D"))
2559
4160
                        }
2560
4161
                else:
2561
4162
                    raise Exception("Cannot display Google layers unless we're using the Spherical Mercator Projection")
2562
4163
2563
4164
2564
4165
            # Mandatory attributes
2565
4166
            #"ApiKey": self.apikey
2566
4167
            output = {
2567
4168
                }
2568
4169
2569
4170
            # Attributes which are defaulted client-side if not set
2570
4171
            if record.satellite_enabled:
2571
4172
                output["Satellite"] = record.satellite or "Google Satellite"
2572
4173
            if record.maps_enabled:
2573
4174
                output["Maps"] = record.maps or "Google Maps"
2574
4175
            if record.hybrid_enabled:
2575
4176
                output["Hybrid"] = record.hybrid or "Google Hybrid"
2576
4177
            if record.mapmaker_enabled:
2577
4178
                output["MapMaker"] = record.mapmaker or "Google MapMaker"
2578
4179
            if record.mapmakerhybrid_enabled:
2579
4180
                output["MapMakerHybrid"] = record.mapmakerhybrid or "Google MapMaker Hybrid"
2580
4181
            if record.earth_enabled:
2581
4182
                output["Earth"] = str(T("Switch to 3D"))
2582
4183
            if record.streetview_enabled and not (record.mapmaker_enabled or record.mapmakerhybrid_enabled):
2583
4184
                # Streetview doesn't work with v2 API
2584
4185
                output["StreetviewButton"] = str(T("Click where you want to open Streetview"))
2585
4186
                output["StreetviewTitle"] = str(T("Street View"))
2586
4187
2587
4188
            return output
2588
4189
        else:
2589
4248
            return None
4190
            return None
2590
4249
4191
2591
4250
        config = gis.get_config()
2592
4251
        if Projection(gis, id=config.projection_id).epsg != 900913:
2593
4252
            # Cannot display Google layers unless we're using the
2594
4253
            # Spherical Mercator Projection
2595
4254
            if record.earth_enabled:
2596
4255
                # But the Google Earth panel can still be enabled
2597
4256
                output = {
2598
4257
                    "Earth": str(T("Switch to 3D"))
2599
4258
                    }
2600
4259
                return output
2601
4260
            else:
2602
4261
                return None
2603
4262
2604
4263
        # Mandatory attributes
2605
4264
        #"ApiKey": self.apikey
2606
4265
        output = {
2607
4266
            }
2608
4267
2609
4268
        # Attributes which are defaulted client-side if not set
2610
4269
        if record.satellite_enabled:
2611
4270
            output["Satellite"] = record.satellite or "Google Satellite"
2612
4271
        if record.maps_enabled:
2613
4272
            output["Maps"] = record.maps or "Google Maps"
2614
4273
        if record.hybrid_enabled:
2615
4274
            output["Hybrid"] = record.hybrid or "Google Hybrid"
2616
4275
        if record.mapmaker_enabled:
2617
4276
            output["MapMaker"] = record.mapmaker or "Google MapMaker"
2618
4277
        if record.mapmakerhybrid_enabled:
2619
4278
            output["MapMakerHybrid"] = record.mapmakerhybrid or "Google MapMaker Hybrid"
2620
4279
        if record.earth_enabled:
2621
4280
            output["Earth"] = str(T("Switch to 3D"))
2622
4281
        if record.streetview_enabled and not (record.mapmaker_enabled or record.mapmakerhybrid_enabled):
2623
4282
            # Streetview doesn't work with v2 API
2624
4283
            output["StreetviewButton"] = str(T("Click where you want to open Streetview"))
2625
4284
            output["StreetviewTitle"] = str(T("Street View"))
2626
4285
2627
4286
        return output
2628
4287
2629
4288
# -----------------------------------------------------------------------------
4192
# -----------------------------------------------------------------------------
2631
4289
class Yahoo(OneLayer):
4193
class YahooLayer(SingleRecordLayer):
2632
4290
    """
4194
    """
2633
4291
        Yahoo Layers from Catalogue
4195
        Yahoo Layers from Catalogue
2634
4292
4196
2635
4293
        NB This will stop working on 13 September 2011
4197
        NB This will stop working on 13 September 2011
2636
4294
        http://developer.yahoo.com/blogs/ydn/posts/2011/06/yahoo-maps-apis-service-closure-announcement-new-maps-offerings-coming-soon/
4198
        http://developer.yahoo.com/blogs/ydn/posts/2011/06/yahoo-maps-apis-service-closure-announcement-new-maps-offerings-coming-soon/
2637
4295
    """
4199
    """
2659
4296
    def __init__(self, gis, record=None):
4200
    js_array = "S3.gis.Yahoo"
2660
4297
        db = current.db
4201
    table_name = "gis_layer_yahoo"
2661
4298
        tablename = "gis_layer_yahoo"
4202
    
2662
4299
        try:
4203
    def __init__(self, gis):
2663
4300
            table = db[tablename]
4204
        super(YahooLayer, self).__init__(gis)
2664
4301
        except:
4205
        if self.record:
2665
4302
            current.manager.load(tablename)
4206
            self.scripts.append("http://api.maps.yahoo.com/ajaxymap?v=3.8&appid=%s" % self.apikey)
2666
4303
            table = db[tablename]
4207
        config = gis.get_config()
2667
4304
        if not record:
4208
        if Projection(gis, id=config.projection_id).epsg != 900913:
2668
4305
            # There is only ever 1 layer
4209
            raise Exception("Cannot display Yahoo layers unless we're using the Spherical Mercator Projection")
2648
4306
            record = db(table.id > 0).select().first()
2649
4307
2650
4308
        self.gis = gis
2651
4309
        self.table = table
2652
4310
        self.js_array = "S3.gis.Yahoo"
2653
4311
        self.record = record
2654
4312
        self._refresh()
2655
4313
        if record:
2656
4314
            self.scripts = ["http://api.maps.yahoo.com/ajaxymap?v=3.8&appid=%s" % self.apikey]
2657
4315
        else:
2658
4316
            self.scripts = []
2669
4317
4210
2670
4318
    def as_dict(self):
4211
    def as_dict(self):
2671
4319
        gis = self.gis
2672
4320
        record = self.record
4212
        record = self.record
2699
4321
        apikey = self.apikey
4213
        if record is not None:
2700
4322
4214
            # Mandatory attributes
2701
4323
        if not apikey:
4215
            #"ApiKey": self.apikey
2702
4324
            # Cannot display Yahoo layers if we have no valid API Key
4216
            output = {
2703
4325
            return None
4217
                }
2704
4326
4218
2705
4327
        config = gis.get_config()
4219
            # Attributes which are defaulted client-side if not set
2706
4328
        if Projection(gis, id=config.projection_id).epsg != 900913:
4220
            if record.satellite_enabled:
2707
4329
            # Cannot display Yahoo layers unless we're using the
4221
                output["Satellite"] = record.satellite or "Yahoo Satellite"
2708
4330
            # Spherical Mercator Projection
4222
            if record.maps_enabled:
2709
4331
            return None
4223
                output["Maps"] = record.maps or "Yahoo Maps"
2710
4332
4224
            if record.hybrid_enabled:
2711
4333
        # Mandatory attributes
4225
                output["Hybrid"] = record.hybrid or "Yahoo Hybrid"
2712
4334
        #"ApiKey": self.apikey
4226
2713
4335
        output = {
4227
            return output
2714
4336
            }
4228
        else:
2715
4337
4229
            return None
2716
4338
        # Attributes which are defaulted client-side if not set
4230
2717
4339
        if record.satellite_enabled:
4231
class MultiRecordLayer(Layer):
2718
4340
            output["Satellite"] = record.satellite or "Yahoo Satellite"
4232
    def __init__(self, gis):
2719
4341
        if record.maps_enabled:
4233
        super(MultiRecordLayer, self).__init__(gis)
2720
4342
            output["Maps"] = record.maps or "Yahoo Maps"
4234
        self.sublayers = []
2721
4343
        if record.hybrid_enabled:
4235
        self.scripts = []
2722
4344
            output["Hybrid"] = record.hybrid or "Yahoo Hybrid"
4236
2723
4345
4237
        auth = gis.auth
2724
4346
        return output
4238
        
2725
4239
        layer_type_list = []
2726
4240
        # Read the enabled Layers
2727
4241
        for record in current.db(self.table.enabled == True).select():
2728
4242
            # Check user is allowed to access the layer
2729
4243
            role_required = record.role_required
2730
4244
            if (not role_required) or auth.s3_has_role(role_required):
2731
4245
                self.sublayers.append(self.SubLayer(gis, record))
2732
4246
2733
4247
    def as_javascript(self):
2734
4248
        """
2735
4249
            Output the Layer as Javascript
2736
4250
            - suitable for inclusion in the HTML page
2737
4251
        """
2738
4252
        sublayer_dicts = []
2739
4253
        for sublayer in self.sublayers:
2740
4254
            # Read the output dict for this sublayer
2741
4255
            sublayer_dict = sublayer.as_dict()
2742
4256
            if sublayer_dict:
2743
4257
                # Add this layer to the list of layers for this layer type
2744
4258
                sublayer_dicts.append(sublayer_dict)
2745
4259
        
2746
4260
        if sublayer_dicts:
2747
4261
            # Output the Layer Type as JSON
2748
4262
            layer_type_json = json.dumps(sublayer_dicts,
2749
4263
                                         sort_keys=True,
2750
4264
                                         indent=4)
2751
4265
            return "%s = %s\n" % (self.js_array, layer_type_json)
2752
4266
        else:
2753
4267
            return None
2754
4268
2755
4269
    class SubLayer(object):
2756
4270
        def __init__(self, gis, record):
2757
4271
            # Ensure all attributes available (even if Null)
2758
4272
            self.gis = gis
2759
4273
            self.__dict__.update(record)
2760
4274
            del record
2761
4275
            self.safe_name = re.sub('[\\"]', "", self.name)
2762
4276
            
2763
4277
            if hasattr(self, "marker_id"):
2764
4278
                self.marker = Marker(gis, self.marker_id)
2765
4279
            if hasattr(self, "projection_id"):
2766
4280
                self.projection = Projection(gis, self.projection_id)
2767
4281
2768
4282
        def setup_clustering(self, output):
2769
4283
            gis = self.gis
2770
4284
            cluster_distance = gis.cluster_distance
2771
4285
            cluster_threshold = gis.cluster_threshold
2772
4286
            if self.cluster_distance != cluster_distance:
2773
4287
                output["cluster_distance"] = self.cluster_distance
2774
4288
            if self.cluster_threshold != cluster_threshold:
2775
4289
                output["cluster_threshold"] = self.cluster_threshold
2776
4290
                
2777
4291
        def setup_visibility_and_opacity(self, output):
2778
4292
            if not self.visible:
2779
4293
                output["visibility"] = False
2780
4294
            if self.opacity != 1:
2781
4295
                output["opacity"] = "%.1f" % self.opacity
2782
4296
2783
4297
        def add_attributes_if_not_default(self, output, **values_and_defaults):
2784
4298
            # could also write values in debug mode, to check if defaults ignored.
2785
4299
            # could also check values are not being overwritten.
2786
4300
            for key, (value, defaults) in values_and_defaults.iteritems():
2787
4301
                if value not in defaults:
2788
4302
                    output[key] = value
2789
4303
2790
4304
        #def set_marker(self):
2791
4305
        #    " Set the Marker for the Layer "
2792
4306
        #    gis = self.gis
2793
4307
        #    self.marker = Marker(gis, self.marker_id)
2794
4308
2795
4309
        #def set_projection(self):
2796
4310
        #    " Set the Projection for the Layer "
2797
4311
        #    gis = self.gis
2798
4312
        #    self.projection = Projection(gis, self.projection_id)
2799
4347
4313
2800
4348
# -----------------------------------------------------------------------------
4314
# -----------------------------------------------------------------------------
2802
4349
class FeatureLayer(Layer):
4315
class FeatureLayer(MultiRecordLayer):
2803
4350
    """ Feature Layer from Catalogue """
4316
    """ Feature Layer from Catalogue """
2848
4351
    def __init__(self, gis, record=None):
4317
    table_name = "gis_layer_feature"
2849
4352
        db = current.db
4318
    js_array = "S3.gis.layers_features"
2850
4353
        tablename = "gis_layer_feature"
4319
2851
4354
        try:
4320
    class SubLayer(MultiRecordLayer.SubLayer):
2852
4355
            table = db[tablename]
4321
        def __init__(self, gis, record):
2853
4356
        except:
4322
            record_module = record.module
2854
4357
            current.manager.load(tablename)
4323
            if record_module is not None:
2855
4358
            table = db[tablename]
4324
                if record_module not in gis.deployment_settings.modules:
2856
4359
4325
                    raise Exception("%s module is disabled" % record_module)
2857
4360
        self.gis = gis
4326
                if not gis.auth.permission(c=record.module, f=record.resource):
2858
4361
        self.table = table
4327
                    raise Exception("User has no permission to this resource (in ACL)")
2859
4362
        self.js_array = "S3.gis.layers_features"
4328
            else:
2860
4363
        self.record = record
4329
                raise Exception("FeatureLayer Record '%s' has no module" % record.name)
2861
4364
        self._refresh()
4330
            super(FeatureLayer.SubLayer, self).__init__(gis, record)
2862
4365
        self.scripts = []
4331
2863
4366
4332
        def as_dict(self):
2864
4367
    def as_dict(self):
4333
            gis = self.gis
2865
4368
        gis = self.gis
4334
2866
4369
        cluster_distance = gis.cluster_distance
4335
            request = current.request
2867
4370
        cluster_threshold = gis.cluster_threshold
4336
            deployment_settings = gis.deployment_settings
2868
4371
        record = self.record
4337
2869
4372
        marker = self.marker
4338
            url = "%s.geojson?layer=%i" % (URL(self.module, self.resource),
2870
4373
4339
                                           self.id)
2871
4374
        auth = gis.auth
4340
            if self.filter:
2872
4375
        request = current.request
4341
                url = "%s&%s" % (url, self.filter)
2873
4376
        deployment_settings = gis.deployment_settings
4342
2874
4377
4343
            # Mandatory attributes
2875
4378
        if record.module not in deployment_settings.modules:
4344
            output = {
2876
4379
            # Module is disabled
4345
                "name": self.safe_name,
2833
4380
            return
2834
4381
        if not auth.permission(c=record.module, f=record.resource):
2835
4382
            # User has no permission to this resource (in ACL)
2836
4383
            return
2837
4384
2838
4385
        name_safe = self._name_safe(record.name)
2839
4386
2840
4387
        url = "%s.geojson?layer=%i" % (URL(record.module,record.resource),
2841
4388
                                       record.id)
2842
4389
        if record.filter:
2843
4390
            url = "%s&%s" % (url, record.filter)
2844
4391
2845
4392
        # Mandatory attributes
2846
4393
        output = {
2847
4394
                "name": name_safe,
2877
4395
                "url": url,
4346
                "url": url,
2878
4396
                "marker_image": marker.image,
2879
4397
                "marker_height": marker.height,
2880
4398
                "marker_width": marker.width,
2881
4399
            }
4347
            }
2894
4400
4348
            self.marker.add_attributes_to_output(output)
2895
4401
        # Attributes which are defaulted client-side if not set
4349
            self.setup_visibility_and_opacity(output)
2896
4402
        if not record.visible:
4350
            self.setup_clustering(output)
2897
4403
            output["visibility"] = False
4351
2898
4404
        if record.opacity != 1:
4352
            return output
2887
4405
            output["opacity"] = "%.1f" % record.opacity
2888
4406
        if record.cluster_distance != cluster_distance:
2889
4407
            output["cluster_distance"] = record.cluster_distance
2890
4408
        if record.cluster_threshold != cluster_threshold:
2891
4409
            output["cluster_threshold"] = record.cluster_threshold
2892
4410
2893
4411
        return output
2899
4412
4353
2900
4413
# -----------------------------------------------------------------------------
4354
# -----------------------------------------------------------------------------
2902
4414
class GeoJSONLayer(Layer):
4355
class GeoJSONLayer(MultiRecordLayer):
2903
4415
    """ GeoJSON Layer from Catalogue """
4356
    """ GeoJSON Layer from Catalogue """
2936
4416
    def __init__(self, gis, record=None):
4357
    table_name = "gis_layer_geojson"
2937
4417
        db = current.db
4358
    js_array = "S3.gis.layers_geojson"
2938
4418
        tablename = "gis_layer_geojson"
4359
    
2939
4419
        try:
4360
    class SubLayer(MultiRecordLayer.SubLayer):
2940
4420
            table = db[tablename]
4361
        def as_dict(self):
2941
4421
        except:
4362
            # Mandatory attributes
2942
4422
            current.manager.load(tablename)
4363
            output = {
2943
4423
            table = db[tablename]
4364
                "name": self.safe_name,
2944
4424
4365
                "url": self.url,
2913
4425
        self.gis = gis
2914
4426
        self.table = table
2915
4427
        self.js_array = "S3.gis.layers_geojson"
2916
4428
        self.record = record
2917
4429
        self._refresh()
2918
4430
        self.scripts = []
2919
4431
2920
4432
    def as_dict(self):
2921
4433
        gis = self.gis
2922
4434
        cluster_distance = gis.cluster_distance
2923
4435
        cluster_threshold = gis.cluster_threshold
2924
4436
        record = self.record
2925
4437
        marker = self.marker
2926
4438
        projection = self.projection
2927
4439
2928
4440
        name_safe = self._name_safe(record.name)
2929
4441
        # Mandatory attributes
2930
4442
        output = {
2931
4443
                "name": name_safe,
2932
4444
                "url": record.url,
2933
4445
                "marker_image": marker.image,
2934
4446
                "marker_height": marker.height,
2935
4447
                "marker_width": marker.width,
2945
4448
            }
4366
            }
2960
4449
4367
            self.marker.add_attributes_to_output(output)
2961
4450
        # Attributes which are defaulted client-side if not set
4368
2962
4451
        if projection.epsg != 4326:
4369
            # Attributes which are defaulted client-side if not set
2963
4452
            output["projection"] = projection.epsg
4370
            projection = self.projection
2964
4453
        if not record.visible:
4371
            if projection.epsg != 4326:
2965
4454
            output["visibility"] = False
4372
                output["projection"] = projection.epsg
2966
4455
        if record.opacity != 1:
4373
            self.setup_visibility_and_opacity(output)
2967
4456
            output["opacity"] = "%.1f" % record.opacity
4374
            self.setup_clustering(output)
2968
4457
        if record.cluster_distance != cluster_distance:
4375
2969
4458
            output["cluster_distance"] = record.cluster_distance
4376
            return output
2956
4459
        if record.cluster_threshold != cluster_threshold:
2957
4460
            output["cluster_threshold"] = record.cluster_threshold
2958
4461
2959
4462
        return output
2970
4463
4377
2971
4464
# -----------------------------------------------------------------------------
4378
# -----------------------------------------------------------------------------
2973
4465
class GeoRSSLayer(Layer):
4379
class GeoRSSLayer(MultiRecordLayer):
2974
4466
    """ GeoRSS Layer from Catalogue """
4380
    """ GeoRSS Layer from Catalogue """
3080
4467
    def __init__(self, gis, record=None):
4381
    table_name = "gis_layer_georss"
3081
4468
        db = current.db
4382
    js_array = "S3.gis.layers_georss"
3082
4469
        tablename = "gis_layer_georss"
4383
    
3083
4470
        try:
4384
    def __init__(self, gis):
3084
4471
            table = db[tablename]
4385
        super(GeoRSSLayer, self).__init__(gis)
3085
4472
        except:
4386
        GeoRSSLayer.SubLayer.cachetable = current.db.gis_cache
3086
4473
            current.manager.load(tablename)
4387
3087
4474
            table = db[tablename]
4388
    class SubLayer(MultiRecordLayer.SubLayer):
3088
4475
4389
        def as_dict(self):
3089
4476
        self.gis = gis
4390
            gis = self.gis
3090
4477
        self.table = table
4391
            
3091
4478
        self.cachetable = db.gis_cache
4392
            db = current.db
3092
4479
        self.js_array = "S3.gis.layers_georss"
4393
            request = current.request
3093
4480
        self.record = record
4394
            public_url = gis.public_url
3094
4481
        self._refresh()
4395
            cachetable = self.cachetable
3095
4482
        self.scripts = []
4396
            
3096
4483
4397
            url = self.url
3097
4484
    def as_dict(self):
4398
            # Check to see if we should Download layer to the cache
3098
4485
        gis = self.gis
4399
            download = True
3099
4486
        cluster_distance = gis.cluster_distance
4400
            query = (cachetable.source == url)
3100
4487
        cluster_threshold = gis.cluster_threshold
4401
            existing_cached_copy = db(query).select(cachetable.modified_on,
3101
4488
        record = self.record
4402
                                      limitby=(0, 1)).first()
3102
4489
        marker = self.marker
4403
            refresh = self.refresh or 900 # 15 minutes set if we have no data (legacy DB)
3103
4490
4404
            if existing_cached_copy:
3104
4491
        db = current.db
4405
                modified_on = existing_cached_copy.modified_on
3105
4492
        request = current.request
4406
                cutoff = modified_on + timedelta(seconds=refresh)
3106
4493
        public_url = gis.public_url
4407
                if request.utcnow < cutoff:
3107
4494
        cachetable = self.cachetable
4408
                    download = False
3108
4495
4409
            if download:
3109
4496
        url = record.url
4410
                # Download layer to the Cache
3110
4497
        # Check to see if we should Download layer to the cache
4411
                # @ToDo: Call directly without going via HTTP
3111
4498
        download = True
4412
                #        s3mgr = current.manager
3112
4499
        query = (cachetable.source == url)
4413
                # @ToDo: Make this async by using Celery (also use this for the refresh time)
3113
4500
        cached = db(query).select(cachetable.modified_on,
4414
                fields = ""
3114
4501
                                  limitby=(0, 1)).first()
4415
                if self.data:
3115
4502
        refresh = record.refresh or 900 # 15 minutes set if we have no data (legacy DB)
4416
                    fields = "&data_field=%s" % self.data
3116
4503
        if cached:
4417
                if self.image:
3117
4504
            modified_on = cached.modified_on
4418
                    fields = "%s&image_field=%s" % (fields, self.image)
3118
4505
            cutoff = modified_on + timedelta(seconds=refresh)
4419
                _url = "%s%s/update.georss?fetchurl=%s%s" % (public_url,
3119
4506
            if request.utcnow < cutoff:
4420
                                                             URL(c="gis", f="cache_feed"),
3120
4507
                download = False
4421
                                                             url,
3121
4508
        if download:
4422
                                                             fields)
3122
4509
            # Download layer to the Cache
4423
                try:
3123
4510
            # @ToDo: Call directly without going via HTTP
4424
                    # @ToDo: Need to commit to not have DB locked with SQLite?
3124
4511
            #        s3mgr = current.manager
4425
                    fetch(_url)
3125
4512
            # @ToDo: Make this async by using Celery (also use this for the refresh time)
4426
                    if existing_cached_copy:
3126
4513
            fields = ""
4427
                        # Clear old selfs which are no longer active
3127
4514
            if record.data:
4428
                        query = (cachetable.source == url) & \
3128
4515
                fields = "&data_field=%s" % record.data
4429
                                (cachetable.modified_on < cutoff)
3129
4516
            if record.image:
4430
                        db(query).delete()
3130
4517
                fields = "%s&image_field=%s" % (fields, record.image)
4431
                except:
3131
4518
            _url = "%s%s/update.georss?fetchurl=%s%s" % (public_url,
4432
                    # Feed down
3132
4519
                                                         URL(c="gis", f="cache_feed"),
4433
                    if existing_cached_copy:
3133
4520
                                                         url,
4434
                        # Use cached copy
3134
4521
                                                         fields)
4435
                        # Should we Update timestamp to prevent every
3135
4522
            try:
4436
                        # subsequent request attempting the download?
3136
4523
                # @ToDo: Need to commit to not have DB locked with SQLite?
4437
                        #query = (cachetable.source == url)
3137
4524
                fetch(_url)
4438
                        #db(query).update(modified_on=request.utcnow)
3138
4525
                if cached:
4439
                        pass
3139
4526
                    # Clear old records which are no longer active
4440
                    else:
3140
4527
                    query = (cachetable.source == url) & \
4441
                        raise Exception("No cached copy available - skip layer")
3141
4528
                            (cachetable.modified_on < cutoff)
4442
3142
4529
                    db(query).delete()
4443
            name_safe = self.safe_name
3143
4530
            except:
4444
3144
4531
                # Feed down
4445
            # Pass the GeoJSON URL to the client
3145
4532
                if cached:
4446
            # Filter to the source of this feed
3146
4533
                    # Use cached copy
4447
            url = "%s.geojson?cache.source=%s" % (URL(c="gis", f="cache_feed"),
3147
4534
                    # Should we Update timestamp to prevent every
4448
                                                  url)
3148
4535
                    # subsequent request attempting the download?
4449
3149
4536
                    #query = (cachetable.source == url)
4450
            # Mandatory attributes
3150
4537
                    #db(query).update(modified_on=request.utcnow)
4451
            output = {
3151
4538
                    pass
4452
                    "name": name_safe,
3152
4539
                else:
4453
                    "url": url,
3153
4540
                    # No cached copy available - skip layer
4454
                }
3154
4541
                    return
4455
            self.marker.add_attributes_to_output(output)
3155
4542
4456
3156
4543
        name_safe = self._name_safe(record.name)
4457
            # Attributes which are defaulted client-side if not set
3157
4544
4458
            if self.refresh != 900:
3158
4545
        # Pass the GeoJSON URL to the client
4459
                output["refresh"] = self.refresh
3159
4546
        # Filter to the source of this feed
4460
            self.setup_visibility_and_opacity(output)
3160
4547
        url = "%s.geojson?cache.source=%s" % (URL(c="gis", f="cache_feed"),
4461
            self.setup_clustering(output)
3161
4548
                                              url)
4462
3162
4549
4463
            return output
3058
4550
        # Mandatory attributes
3059
4551
        output = {
3060
4552
                "name": name_safe,
3061
4553
                "url": url,
3062
4554
                "marker_image": marker.image,
3063
4555
                "marker_height": marker.height,
3064
4556
                "marker_width": marker.width,
3065
4557
            }
3066
4558
3067
4559
        # Attributes which are defaulted client-side if not set
3068
4560
        if record.refresh != 900:
3069
4561
            output["refresh"] = record.refresh
3070
4562
        if not record.visible:
3071
4563
            output["visibility"] = False
3072
4564
        if record.opacity != 1:
3073
4565
            output["opacity"] = "%.1f" % record.opacity
3074
4566
        if record.cluster_distance != cluster_distance:
3075
4567
            output["cluster_distance"] = record.cluster_distance
3076
4568
        if record.cluster_threshold != cluster_threshold:
3077
4569
            output["cluster_threshold"] = record.cluster_threshold
3078
4570
3079
4571
        return output
3163
4572
4464
3164
4573
# -----------------------------------------------------------------------------
4465
# -----------------------------------------------------------------------------
3166
4574
class GPXLayer(Layer):
4466
class GPXLayer(MultiRecordLayer):
3167
4575
    """ GPX Layer from Catalogue """
4467
    """ GPX Layer from Catalogue """
3239
4576
    def __init__(self, gis, record=None):
4468
    table_name = "gis_layer_gpx"
3240
4577
        db = current.db
4469
    js_array = "S3.gis.layers_gpx"
3241
4578
        tablename = "gis_layer_gpx"
4470
    
3242
4579
        try:
4471
    def __init__(self, gis):
3243
4580
            table = db[tablename]
4472
        super(GPXLayer, self).__init__(gis)
3244
4581
        except:
4473
3245
4582
            current.manager.load(tablename)
4474
#        if record:
3246
4583
            table = db[tablename]
4475
#            self.url = "%s/%s" % (URL(c="default", f="download"),
3247
4584
4476
#                                  record.track)
3248
4585
        self.gis = gis
4477
#        else:
3249
4586
        self.table = table
4478
#            self.url = None
3250
4587
        self.js_array = "S3.gis.layers_gpx"
4479
3251
4588
        self.record = record
4480
    class SubLayer(MultiRecordLayer.SubLayer):
3252
4589
        self._refresh()
4481
        def as_dict(self):
3253
4590
        self.scripts = []
4482
            gis = self.gis
3254
4591
4483
            request = current.request
3255
4592
    def as_dict(self):
4484
3256
4593
        gis = self.gis
4485
            url = URL(c="default", f="download",
3257
4594
        cluster_distance = gis.cluster_distance
4486
                      args=self.track)
3258
4595
        cluster_threshold = gis.cluster_threshold
4487
            
3259
4596
        record = self.record
4488
            # Mandatory attributes
3260
4597
        marker = self.marker
4489
            output = {
3261
4598
4490
                    "name": self.safe_name,
3262
4599
        name_safe = self._name_safe(record.name)
4491
                    "url": url,
3263
4600
4492
                }
3264
4601
        request = current.request
4493
            self.marker.add_attributes_to_output(output)
3265
4602
        url = URL(c="default", f="download",
4494
            self.add_attributes_if_not_default(
3266
4603
                  args=record.track)
4495
                output,
3267
4604
4496
                waypoints = (self.waypoints, (True,)),
3268
4605
        # Mandatory attributes
4497
                tracks = (self.tracks, (True,)),
3269
4606
        output = {
4498
                routes = (self.routes, (True,)),
3270
4607
                "name": name_safe,
4499
            )
3271
4608
                "url": url,
4500
            self.setup_visibility_and_opacity(output)
3272
4609
                "marker_image": marker.image,
4501
            self.setup_clustering(output)
3273
4610
                "marker_height": marker.height,
4502
            return output
3203
4611
                "marker_width": marker.width,
3204
4612
            }
3205
4613
3206
4614
        # Attributes which are defaulted client-side if not set
3207
4615
        if not record.waypoints:
3208
4616
            output["waypoints"] = False
3209
4617
        if not record.tracks:
3210
4618
            output["tracks"] = False
3211
4619
        if not record.routes:
3212
4620
            output["routes"] = False
3213
4621
        if not record.visible:
3214
4622
            output["visibility"] = False
3215
4623
        if record.opacity != 1:
3216
4624
            output["opacity"] = "%.1f" % record.opacity
3217
4625
        if record.cluster_distance != cluster_distance:
3218
4626
            output["cluster_distance"] = record.cluster_distance
3219
4627
        if record.cluster_threshold != cluster_threshold:
3220
4628
            output["cluster_threshold"] = record.cluster_threshold
3221
4629
3222
4630
        return output
3223
4631
3224
4632
    def refresh(self):
3225
4633
        " Refresh the attributes of the Layer "
3226
4634
        gis = self.gis
3227
4635
        request = current.request
3228
4636
        record = self.record
3229
4637
        table = self.table
3230
4638
        if "marker_id" in table:
3231
4639
            self.set_marker()
3232
4640
        if "projection_id" in table:
3233
4641
            self.set_projection()
3234
4642
        if record:
3235
4643
            self.url = "%s/%s" % (URL(c="default", f="download"),
3236
4644
                                  record.track)
3237
4645
        else:
3238
4646
            self.url = None
3274
4647
4503
3275
4648
# -----------------------------------------------------------------------------
4504
# -----------------------------------------------------------------------------
3277
4649
class KMLLayer(Layer):
4505
class KMLLayer(MultiRecordLayer):
3278
4650
    """ KML Layer from Catalogue """
4506
    """ KML Layer from Catalogue """
3297
4651
    def __init__(self, gis, record=None):
4507
    table_name = "gis_layer_kml"
3298
4652
        db = current.db
4508
    js_array = "S3.gis.layers_kml"
3299
4653
        tablename = "gis_layer_kml"
4509
    
3300
4654
        try:
4510
    def __init__(self, gis):
3301
4655
            table = db[tablename]
4511
        super(KMLLayer, self).__init__(gis)
3302
4656
        except:
4512
        
3303
4657
            current.manager.load(tablename)
4513
        "Set up the KML cache, should be done once per request"
3286
4658
            table = db[tablename]
3287
4659
3288
4660
        self.gis = gis
3289
4661
        self.table = table
3290
4662
        # @ToDo: Migrate to gis_cache
3291
4663
        self.cachetable = db.gis_cache2
3292
4664
        self.js_array = "S3.gis.layers_kml"
3293
4665
        self.record = record
3294
4666
        self._refresh()
3295
4667
        self.scripts = []
3296
4668
3304
4669
        # Can we cache downloaded KML feeds?
4514
        # Can we cache downloaded KML feeds?
3305
4670
        # Needed for unzipping & filtering as well
4515
        # Needed for unzipping & filtering as well
3306
4671
        # @ToDo: Should we move this folder to static to speed up access to cached content?
4516
        # @ToDo: Should we move this folder to static to speed up access to cached content?
3307
@@ -4676,263 +4521,172 @@
3308
4676
        else:
4521
        else:
3309
4677
            try:
4522
            try:
3310
4678
                os.mkdir(cachepath)
4523
                os.mkdir(cachepath)
3311
4524
            except OSError, os_error:
3312
4525
                self.gis.debug(
3313
4526
                    "GIS: KML layers cannot be cached: %s %s" % (
3314
4527
                        cachepath,
3315
4528
                        os_error
3316
4529
                    )
3317
4530
                )
3318
4531
                cacheable = False
3319
4532
            else:
3320
4679
                cacheable = True
4533
                cacheable = True
3374
4680
            except:
4534
        # @ToDo: Migrate to gis_cache
3375
4681
                cacheable = False
4535
        KMLLayer.cachetable = current.db.gis_cache2
3376
4682
        self.cacheable = cacheable
4536
        KMLLayer.cacheable = cacheable
3377
4683
        self.cachepath = cachepath
4537
        KMLLayer.cachepath = cachepath
3378
4684
4538
        
3379
4685
    def as_dict(self):
4539
        
3380
4686
        gis = self.gis
4540
    class SubLayer(MultiRecordLayer.SubLayer):
3381
4687
        cluster_distance = gis.cluster_distance
4541
        def as_dict(self):
3382
4688
        cluster_threshold = gis.cluster_threshold
4542
            gis = self.gis
3383
4689
        record = self.record
4543
3384
4690
        marker = self.marker
4544
            T = current.T
3385
4691
4545
            db = current.db
3386
4692
        T = current.T
4546
            request = current.request
3387
4693
        db = current.db
4547
            response = current.response
3388
4694
        request = current.request
4548
            public_url = gis.public_url
3389
4695
        response = current.response
4549
            
3390
4696
        public_url = gis.public_url
4550
            cachetable = KMLLayer.cachetable
3391
4697
        cacheable = self.cacheable
4551
            cacheable = KMLLayer.cacheable
3392
4698
        cachepath = self.cachepath
4552
            cachepath = KMLLayer.cachepath
3393
4699
        cachetable = self.cachetable
4553
3394
4700
4554
            name = self.name
3395
4701
        name = record.name
4555
            if cacheable:
3396
4702
        name_safe = self._name_safe(record.name)
4556
                _name = urllib2.quote(name)
3397
4703
4557
                _name = _name.replace("%", "_")
3398
4704
        if cacheable:
4558
                filename = "%s.file.%s.kml" % (cachetable._tablename,
3399
4705
            _name = urllib2.quote(name)
4559
                                               _name)
3400
4706
            _name = _name.replace("%", "_")
4560
3401
4707
            filename = "%s.file.%s.kml" % (cachetable._tablename,
4561
                # Should we download a fresh copy of the source file?
3402
4708
                                           _name)
4562
                download = True
3403
4709
4563
                query = (cachetable.name == name)
3404
4710
            # Should we download a fresh copy of the source file?
4564
                cached = db(query).select(cachetable.modified_on,
3405
4711
            download = True
4565
                                          limitby=(0, 1)).first()
3406
4712
            query = (cachetable.name == name)
4566
                refresh = self.refresh or 900 # 15 minutes set if we have no data (legacy DB)
3354
4713
            cached = db(query).select(cachetable.modified_on,
3355
4714
                                      limitby=(0, 1)).first()
3356
4715
            refresh = record.refresh or 900 # 15 minutes set if we have no data (legacy DB)
3357
4716
            if cached:
3358
4717
                modified_on = cached.modified_on
3359
4718
                cutoff = modified_on + timedelta(seconds=refresh)
3360
4719
                if request.utcnow < cutoff:
3361
4720
                    download = False
3362
4721
3363
4722
            if download:
3364
4723
                # Download file
3365
4724
                if response.s3.tasks_active():
3366
4725
                    # Async call
3367
4726
                    db.task_scheduled.insert(name="download_kml_%s" % uuid.uuid4(),
3368
4727
                                             func="download_kml",
3369
4728
                                             args=json.dumps([record.id,
3370
4729
                                                              filename]))
3371
4730
                else:
3372
4731
                    # Sync call
3373
4732
                    gis.download_kml(record.id, filename)
3407
4733
                if cached:
4567
                if cached:
3445
4734
                    db(query).update(modified_on=request.utcnow)
4568
                    modified_on = cached.modified_on
3446
4735
                else:
4569
                    cutoff = modified_on + timedelta(seconds=refresh)
3447
4736
                    cachetable.insert(name=name, file=filename)
4570
                    if request.utcnow < cutoff:
3448
4737
4571
                        download = False
3449
4738
            url = URL(c="default", f="download",
4572
3450
4739
                      args=[filename])
4573
                if download:
3451
4740
        else:
4574
                    # Download file
3452
4741
            # No caching possible (e.g. GAE), display file direct from remote (using Proxy)
4575
                    if response.s3.tasks_active():
3453
4742
            # (Requires OpenLayers.Layer.KML to be available)
4576
                        # Async call
3454
4743
            url = record.url
4577
                        db.task_scheduled.insert(name="download_kml_%s" % uuid.uuid4(),
3455
4744
4578
                                                 func="download_kml",
3456
4745
        # Mandatory attributes
4579
                                                 args=json.dumps([record.id,
3457
4746
        output = {
4580
                                                                  filename]))
3458
4747
                "name": name_safe,
4581
                    else:
3459
4748
                "url": url,
4582
                        # Sync call
3460
4749
                "marker_image": marker.image,
4583
                        gis.download_kml(self.id, filename)
3461
4750
                "marker_height": marker.height,
4584
                    if cached:
3462
4751
                "marker_width": marker.width,
4585
                        db(query).update(modified_on=request.utcnow)
3463
4752
            }
4586
                    else:
3464
4753
4587
                        cachetable.insert(name=name, file=filename)
3465
4754
        # Attributes which are defaulted client-side if not set
4588
3466
4755
        if record.title and record.title != "name":
4589
                url = URL(r=request, c="default", f="download",
3467
4756
            output["title"] = record.title
4590
                          args=[filename])
3468
4757
        if record.body and record.body != "description":
4591
            else:
3469
4758
            output["body"] = record.body
4592
                # No caching possible (e.g. GAE), display file direct from remote (using Proxy)
3470
4759
        if record.refresh != 900:
4593
                # (Requires OpenLayers.Layer.KML to be available)
3471
4760
            output["refresh"] = record.refresh
4594
                url = self.url
3472
4761
        if not record.visible:
4595
3473
4762
            output["visibility"] = False
4596
            output = dict(
3474
4763
        if record.opacity != 1:
4597
                name = self.safe_name,
3475
4764
            output["opacity"] = "%.1f" % record.opacity
4598
                url = url,
3476
4765
        if record.cluster_distance != cluster_distance:
4599
            )
3477
4766
            output["cluster_distance"] = record.cluster_distance
4600
            self.add_attributes_if_not_default(
3478
4767
        if record.cluster_threshold != cluster_threshold:
4601
                output,
3479
4768
            output["cluster_threshold"] = record.cluster_threshold
4602
                title = (self.title, ("name", None, "")),
3480
4769
4603
                body = (self.body, ("description", None)),
3481
4770
        return output
4604
                refresh = (self.refresh, (900,)),
3482
4605
            )
3483
4606
            self.setup_visibility_and_opacity(output)
3484
4607
            self.setup_clustering(output)
3485
4608
            self.marker.add_attributes_to_output(output)
3486
4609
            return output
3487
4771
4610
3488
4772
# -----------------------------------------------------------------------------
4611
# -----------------------------------------------------------------------------
3490
4773
class TMSLayer(Layer):
4612
class TMSLayer(MultiRecordLayer):
3491
4774
    """ TMS Layer from Catalogue """
4613
    """ TMS Layer from Catalogue """
3534
4775
    def __init__(self, gis, record=None):
4614
    table_name = "gis_layer_tms"
3535
4776
        db = current.db
4615
    js_array = "S3.gis.layers_tms"
3536
4777
        tablename = "gis_layer_tms"
4616
3537
4778
        try:
4617
    class SubLayer(MultiRecordLayer.SubLayer):
3538
4779
            table = db[tablename]
4618
        def as_dict(self):
3539
4780
        except:
4619
            output = {
3540
4781
            current.manager.load(tablename)
4620
                    "name": self.safe_name,
3541
4782
            table = db[tablename]
4621
                    "url": self.url,
3542
4783
4622
                    "layername": self.layername
3543
4784
        self.gis = gis
4623
                }
3544
4785
        self.table = table
4624
            self.add_attributes_if_not_default(
3545
4786
        self.js_array = "S3.gis.layers_tms"
4625
                output,
3546
4787
        self.record = record
4626
                url2 = (self.url2, (None,)),
3547
4788
        self._refresh()
4627
                url3 = (self.url3, (None,)),
3548
4789
        self.scripts = []
4628
                format = (self.img_format, ("png", None)),
3549
4790
4629
                zoomLevels = (self.zoom_levels, (9,)),
3550
4791
    def as_dict(self):
4630
                attribution = (self.attribution, (None,)),
3551
4792
        #gis = self.gis
4631
            )
3552
4793
        record = self.record
4632
            return output
3511
4794
3512
4795
        name_safe = self._name_safe(record.name)
3513
4796
3514
4797
        # Mandatory attributes
3515
4798
        output = {
3516
4799
                "name": name_safe,
3517
4800
                "url": record.url,
3518
4801
                "layername": record.layername
3519
4802
            }
3520
4803
3521
4804
        # Attributes which are defaulted client-side if not set
3522
4805
        if record.url2:
3523
4806
            output["url2"] = record.url2
3524
4807
        if record.url3:
3525
4808
            output["url3"] = record.url3
3526
4809
        if record.img_format != "png":
3527
4810
             output["format"] = record.img_format
3528
4811
        if record.zoom_levels != 9:
3529
4812
            output["zoomLevels"] = record.zoom_levels
3530
4813
        if record.attribution:
3531
4814
            output["attribution"] = record.attribution
3532
4815
3533
4816
        return output
3553
4817
4633
3554
4818
# -----------------------------------------------------------------------------
4634
# -----------------------------------------------------------------------------
3556
4819
class WFSLayer(Layer):
4635
class WFSLayer(MultiRecordLayer):
3557
4820
    """ WFS Layer from Catalogue """
4636
    """ WFS Layer from Catalogue """
3591
4821
    def __init__(self, gis, record=None):
4637
    table_name = "gis_layer_wfs"
3592
4822
        db = current.db
4638
    js_array = "S3.gis.layers_wfs"
3593
4823
        tablename = "gis_layer_wfs"
4639
    
3594
4824
        try:
4640
    class SubLayer(MultiRecordLayer.SubLayer):
3595
4825
            table = db[tablename]
4641
        def as_dict(self):
3596
4826
        except:
4642
            output = dict(
3597
4827
            current.manager.load(tablename)
4643
                name = self.safe_name,
3598
4828
            table = db[tablename]
4644
                url = self.url,
3599
4829
4645
                title = self.title,
3600
4830
        self.gis = gis
4646
                featureType = self.featureType,
3601
4831
        self.table = table
4647
                featureNS = self.featureNS,
3602
4832
        self.js_array = "S3.gis.layers_wfs"
4648
                schema = self.wfs_schema,
3603
4833
        self.record = record
4649
            )
3604
4834
        self._refresh()
4650
            self.add_attributes_if_not_default(
3605
4835
        self.scripts = []
4651
                output,
3606
4836
4652
                version = (self.version, ("1.1.0",)),
3607
4837
    def as_dict(self):
4653
                geometryName = (self.geometryName, ("the_geom",)),
3608
4838
        gis = self.gis
4654
                styleField = (self.style_field, (None,)),
3609
4839
        cluster_distance = gis.cluster_distance
4655
                styleValues = (self.style_values, ("{}", None)),
3610
4840
        cluster_threshold = gis.cluster_threshold
4656
                projection = (self.projection.epsg, (4326,)),
3578
4841
        record = self.record
3579
4842
        projection = self.projection
3580
4843
3581
4844
        name_safe = self._name_safe(record.name)
3582
4845
3583
4846
        # Mandatory attributes
3584
4847
        output = {
3585
4848
                "name": name_safe,
3586
4849
                "url": record.url,
3587
4850
                "title": record.title,
3588
4851
                "featureType": record.featureType,
3589
4852
                "featureNS": record.featureNS,
3590
4853
                "schema": record.wfs_schema,
3611
4854
                #editable
4657
                #editable
3635
4855
            }
4658
            )
3636
4856
4659
            self.setup_visibility_and_opacity(output)
3637
4857
        # Attributes which are defaulted client-side if not set
4660
            self.setup_clustering(output)
3638
4858
        if record.version != "1.1.0":
4661
            return output
3616
4859
            output["version"] = record.version
3617
4860
        if record.geometryName != "the_geom":
3618
4861
            output["geometryName"] = record.geometryName
3619
4862
        if record.style_field:
3620
4863
            output["styleField"] = record.style_field
3621
4864
        if record.style_values and record.style_values != "{}":
3622
4865
            output["styleValues"] = record.style_values
3623
4866
        if projection.epsg != 4326:
3624
4867
            output["projection"] = projection.epsg
3625
4868
        if not record.visible:
3626
4869
            output["visibility"] = False
3627
4870
        if record.opacity != 1:
3628
4871
            output["opacity"] = "%.1f" % record.opacity
3629
4872
        if record.cluster_distance != cluster_distance:
3630
4873
            output["cluster_distance"] = record.cluster_distance
3631
4874
        if record.cluster_threshold != cluster_threshold:
3632
4875
            output["cluster_threshold"] = record.cluster_threshold
3633
4876
3634
4877
        return output
3639
4878
4662
3640
4879
# -----------------------------------------------------------------------------
4663
# -----------------------------------------------------------------------------
3642
4880
class WMSLayer(Layer):
4664
class WMSLayer(MultiRecordLayer):
3643
4881
    """ WMS Layer from Catalogue """
4665
    """ WMS Layer from Catalogue """
3698
4882
    def __init__(self, gis, record=None):
4666
    js_array = "S3.gis.layers_wms"
3699
4883
        db = current.db
4667
    table_name = "gis_layer_wms"
3700
4884
        tablename = "gis_layer_wms"
4668
3701
4885
        try:
4669
    class SubLayer(MultiRecordLayer.SubLayer):
3702
4886
            table = db[tablename]
4670
        def as_dict(self):
3703
4887
        except:
4671
            output = dict(
3704
4888
            current.manager.load(tablename)
4672
                name = self.safe_name,
3705
4889
            table = db[tablename]
4673
                url = self.url,
3706
4890
4674
                layers = self.layers                
3707
4891
        self.gis = gis
4675
            )
3708
4892
        self.table = table
4676
            self.add_attributes_if_not_default(
3709
4893
        self.js_array = "S3.gis.layers_wms"
4677
                output,
3710
4894
        self.record = record
4678
                transparent = (self.transparent, (True,)),
3711
4895
        self._refresh()
4679
                version = (self.version, ("1.1.1",)),
3712
4896
        self.scripts = []
4680
                format = (self.img_format, ("image/png",)),
3713
4897
4681
                map = (self.map, (None,)),
3714
4898
    def as_dict(self):
4682
                buffer = (self.buffer, (0,)),
3715
4899
        #gis = self.gis
4683
                base = (self.base, (False,)),
3716
4900
        record = self.record
4684
                style = (self.style, (None,)),
3717
4901
4685
                bgcolor = (self.bgcolor, (None,)),
3718
4902
        name_safe = self._name_safe(record.name)
4686
                tiled = (self.tiled, (False, )),
3719
4903
4687
            )
3720
4904
        # Mandatory attributes
4688
            self.setup_visibility_and_opacity(output)
3721
4905
        output = {
4689
            return output
3668
4906
                "name": name_safe,
3669
4907
                "url": record.url,
3670
4908
                "layers": record.layers
3671
4909
            }
3672
4910
3673
4911
        # Attributes which are defaulted client-side if not set
3674
4912
        if not record.visible:
3675
4913
            output["visibility"] = False
3676
4914
        if record.opacity != 1:
3677
4915
            output["opacity"] = "%.1f" % record.opacity
3678
4916
        if not record.transparent:
3679
4917
             output["transparent"] = False
3680
4918
        if record.version != "1.1.1":
3681
4919
             output["version"] = record.version
3682
4920
        if record.img_format != "image/png":
3683
4921
             output["format"] = record.img_format
3684
4922
        if record.map:
3685
4923
             output["map"] = record.map
3686
4924
        if record.style:
3687
4925
             output["style"] = record.style
3688
4926
        if record.bgcolor:
3689
4927
             output["bgcolor"] = record.bgcolor
3690
4928
        if record.tiled:
3691
4929
            output["tiled"] = True
3692
4930
        if record.buffer:
3693
4931
            output["buffer"] = record.buffer
3694
4932
        if record.base:
3695
4933
            output["base"] = True
3696
4934
3697
4935
        return output
3722
4936
4690
3723
4937
# =============================================================================
4691
# =============================================================================
3724
4938
class S3MAP(S3Method):
4692
class S3MAP(S3Method):
3725
@@ -5041,4 +4795,3 @@
3726
5041
        return page
4795
        return page
3727
5042
4796
3728
5043
# END =========================================================================
4797
# END =========================================================================
3729
5044
3730
5045
4798
3731
=== added file 'modules/test_utils/AddedRole.py'
3732
--- modules/test_utils/AddedRole.py	1970-01-01 00:00:00 +0000
3733
+++ modules/test_utils/AddedRole.py	2011-09-05 13:55:13 +0000
3734
@@ -0,0 +1,25 @@
3735
1
3736
2
class AddedRole(object):
3737
3
    """Adds a role and removes it at the end of a test no matter what happens.
3738
4
    
3739
5
    """
3740
6
    def __init__(self, session, role):
3741
7
        self.role = role
3742
8
        self.session = session
3743
9
    
3744
10
    def __enter__(self):
3745
11
        roles = self.session.s3.roles
3746
12
        role = self.role
3747
13
        if not role in roles:
3748
14
            roles.append(role)
3749
15
3750
16
    def __exit__(self, type, value, traceback):
3751
17
        session_s3_roles = self.session.s3.roles
3752
18
        roles = list(session_s3_roles)
3753
19
        for i in range(len(roles)):
3754
20
            session_s3_roles.pop(0)
3755
21
        add_role = session_s3_roles.append
3756
22
        role = self.role
3757
23
        for role in roles:
3758
24
            if role is not role:
3759
25
                add_role(role)
3760
0
26
3761
=== added file 'modules/test_utils/Change.py'
3762
--- modules/test_utils/Change.py	1970-01-01 00:00:00 +0000
3763
+++ modules/test_utils/Change.py	2011-09-05 13:55:13 +0000
3764
@@ -0,0 +1,25 @@
3765
1
3766
2
_UNDEFINED = object()
3767
3
3768
4
class Change(object):
3769
5
    def __init__(self, target, changes):
3770
6
        self.changes = changes
3771
7
        self.target = target
3772
8
    
3773
9
    def __enter__(self):
3774
10
        assert not hasattr(self, "originals")
3775
11
        self.originals = originals = {}
3776
12
        # store originals and set new values
3777
13
        for name, value in self.changes.iteritems():
3778
14
            originals[name] = getattr(self.target, name, _UNDEFINED)
3779
15
            setattr(self.target, name, value)
3780
16
        
3781
17
    def __exit__(self, type, value, traceback):
3782
18
        # restore originals
3783
19
        for name, value in self.originals.iteritems():
3784
20
            if value is _UNDEFINED:
3785
21
                delattr(self, name)
3786
22
            else:
3787
23
                setattr(self.target, name, value)    
3788
24
        del self.originals
3789
25
    
3790
0
26
3791
=== added file 'modules/test_utils/ExpectSessionWarning.py'
3792
--- modules/test_utils/ExpectSessionWarning.py	1970-01-01 00:00:00 +0000
3793
+++ modules/test_utils/ExpectSessionWarning.py	2011-09-05 13:55:13 +0000
3794
@@ -0,0 +1,14 @@
3795
1
3796
2
class ExpectSessionWarning(object):
3797
3
    def __init__(self, session, warning):
3798
4
        self.warning = warning
3799
5
        self.session = session
3800
6
3801
7
    def __enter__(self):
3802
8
        session = self.session
3803
9
        warnings = []
3804
10
        self.warnings = session.warning = warnings
3805
11
3806
12
    def __exit__(self, type, value, traceback):
3807
13
        if type is None:
3808
14
            assert self.warning in self.warnings
3809
0
15
3810
=== added file 'modules/test_utils/ExpectedException.py'
3811
--- modules/test_utils/ExpectedException.py	1970-01-01 00:00:00 +0000
3812
+++ modules/test_utils/ExpectedException.py	2011-09-05 13:55:13 +0000
3813
@@ -0,0 +1,13 @@
3814
1
3815
2
class ExpectedException(object):
3816
3
    def __init__(self, ExceptionClass):
3817
4
        self.ExceptionClass = ExceptionClass
3818
5
    
3819
6
    def __enter__(self):
3820
7
        pass
3821
8
3822
9
    def __exit__(self, type, value, traceback):
3823
10
        return issubclass(type, self.ExceptionClass), (
3824
11
            "%s not raised" % self.ExceptionClass.__name__
3825
12
        )
3826
13
3827
0
14
3828
=== added file 'modules/test_utils/InsertedRecord.py'
3829
--- modules/test_utils/InsertedRecord.py	1970-01-01 00:00:00 +0000
3830
+++ modules/test_utils/InsertedRecord.py	2011-09-05 13:55:13 +0000
3831
@@ -0,0 +1,19 @@
3832
1
3833
2
from clear_table import clear_table
3834
3
3835
4
class InsertedRecord(object):
3836
5
    """Inserts and commits a record and removes it at the end of
3837
6
    a test no matter what happens.
3838
7
    
3839
8
    """
3840
9
    def __init__(self, db, table, data):
3841
10
        self.db = db
3842
11
        self.table = table
3843
12
        self.data = data
3844
13
    
3845
14
    def __enter__(self):
3846
15
        self.table.insert(**self.data)
3847
16
        self.db.commit()
3848
17
        
3849
18
    def __exit__(self, type, value, traceback):
3850
19
        clear_table(self.db, self.table)
3851
0
20
3852
=== added file 'modules/test_utils/Web2pyNosePlugin.py'
3853
--- modules/test_utils/Web2pyNosePlugin.py	1970-01-01 00:00:00 +0000
3854
+++ modules/test_utils/Web2pyNosePlugin.py	2011-09-05 13:55:13 +0000
3855
@@ -0,0 +1,106 @@
3856
1
3857
2
import nose
3858
3
import re
3859
4
from itertools import imap
3860
5
import unittest
3861
6
3862
7
class Web2pyNosePlugin(nose.plugins.base.Plugin):
3863
8
    # see: http://somethingaboutorange.com/mrl/projects/nose/0.11.1/plugins/writing.html
3864
9
    
3865
10
    """This plugin is designed to give the web2py environment to the tests.
3866
11
    """
3867
12
    score = 0
3868
13
    # always enable as this plugin can only 
3869
14
    # be selected by running this script
3870
15
    enabled = True
3871
16
    
3872
17
    def __init__(
3873
18
        self,
3874
19
        application_name,
3875
20
        environment,
3876
21
        directory_pattern,
3877
22
        test_folders
3878
23
    ):
3879
24
        super(Web2pyNosePlugin, self).__init__()
3880
25
        self.application_name = application_name
3881
26
        self.environment = environment
3882
27
        self.directory_pattern = directory_pattern
3883
28
        self.test_folders = test_folders
3884
29
        
3885
30
    def options(self, parser, env):
3886
31
        """Register command line options"""
3887
32
        pass
3888
33
        
3889
34
    def wantDirectory(self, dirname):
3890
35
        return bool(re.search(self.directory_pattern, dirname))
3891
36
3892
37
    def wantFile(self, file_name):
3893
38
        print file_name
3894
39
        return file_name.endswith(".py") and any(
3895
40
            imap(file_name.__contains__, self.test_folders)
3896
41
        )
3897
42
3898
43
    def wantModule(self, module):
3899
44
        return False
3900
45
3901
46
    def loadTestsFromName(self, file_name, discovered):
3902
47
        """Sets up the unit-testing environment.
3903
48
        
3904
49
        This involves loading modules as if by web2py.
3905
50
        Also we must have a test database.
3906
51
        
3907
52
        If testing controllers, tests need to set up the request themselves.
3908
53
                
3909
54
        """
3910
55
        if file_name.endswith(".py"):
3911
56
            
3912
57
            # Is it possible that the module could load 
3913
58
            # other code that is using the original db?
3914
59
            
3915
60
            test_globals = self.environment
3916
61
3917
62
            module_globals = dict(self.environment)
3918
63
            # execfile is used because it doesn't create a module
3919
64
            # or load the module from sys.modules if it exists.
3920
65
            
3921
66
            execfile(file_name, module_globals)
3922
67
            
3923
68
            import inspect
3924
69
            # we have to return something, otherwise nose
3925
70
            # will let others have a go, and they won't pass
3926
71
            # in the web2py environment, so we'll get errors
3927
72
            tests = []
3928
73
    
3929
74
            for name, thing in module_globals.iteritems():
3930
75
                if (
3931
76
                    # don't bother with globally imported things 
3932
77
                    name not in test_globals \
3933
78
                    # unless they have been overridden
3934
79
                    or test_globals[name] is not thing
3935
80
                ):
3936
81
                    if (
3937
82
                        isinstance(thing, type)
3938
83
                        and issubclass(thing, unittest.TestCase)
3939
84
                    ):
3940
85
                        # look for test methods
3941
86
                        for member_name in dir(thing):
3942
87
                            if member_name.startswith("test"):
3943
88
                                if callable(getattr(thing, member_name)):
3944
89
                                    tests.append(thing(member_name))
3945
90
                    elif (
3946
91
                        name.startswith("test") 
3947
92
                        or name.startswith("Test")
3948
93
                    ):
3949
94
                        if inspect.isfunction(thing):
3950
95
                            function = thing
3951
96
                            function_name = name
3952
97
                            # things coming from execfile have no module
3953
98
                            #print file_name, function_name, function.__module__
3954
99
                            if function.__module__ in ("__main__", None):
3955
100
                                tests.append(
3956
101
                                    nose.case.FunctionTestCase(function)
3957
102
                                )
3958
103
            return tests
3959
104
        else:
3960
105
            return []
3961
106
        
3962
0
107
3963
=== modified file 'modules/test_utils/__init__.py'
3964
--- modules/test_utils/__init__.py	2011-08-11 19:25:52 +0000
3965
+++ modules/test_utils/__init__.py	2011-09-05 13:55:13 +0000
3966
@@ -1,2 +1,12 @@
3967
1
1
3968
2
from compare_lines import compare_lines
3969
3
\ No newline at end of file
2
\ No newline at end of file
3970
3
from compare_lines import compare_lines
3971
4
from clear_table import clear_table
3972
5
from find_JSON_format_data_structure import *
3973
6
from Web2pyNosePlugin import Web2pyNosePlugin
3974
7
from assert_equal import *
3975
8
3976
9
from InsertedRecord import *
3977
10
from AddedRole import *
3978
11
from ExpectedException import *
3979
12
from Change import *
3980
13
from ExpectSessionWarning import ExpectSessionWarning
3981
4
14
3982
=== added file 'modules/test_utils/assert_equal.py'
3983
--- modules/test_utils/assert_equal.py	1970-01-01 00:00:00 +0000
3984
+++ modules/test_utils/assert_equal.py	2011-09-05 13:55:13 +0000
3985
@@ -0,0 +1,60 @@
3986
1
3987
2
3988
3
def assert_same_type(expected, actual):
3989
4
    assert isinstance(actual, type(expected)), "%s vs. %s" % (type(expected), type(actual))
3990
5
3991
6
def assert_equal_sequence(expected, actual):
3992
7
    assert len(expected) == len(actual), "length should be %i, not %i:\n%s" % (
3993
8
        len(expected), len(actual), actual
3994
9
    )
3995
10
    for i in range(len(expected)):
3996
11
        try:
3997
12
            assert_equal(expected[i], actual[i])
3998
13
        except AssertionError, assertion_error:
3999
14
            raise AssertionError(
4000
15
                str(assertion_error)
4001
16
            )
4002
17
4003
18
def assert_equal_set(expected, actual):
4004
19
    missing = expected.difference(actual)
4005
20
    assert not missing, "Missing: %s" % ", ".join(missing)
4006
21
4007
22
    extra = actual.difference(expected)
4008
23
    assert not extra, "Extra: %s" % ", ".join(extra)    
4009
24
4010
25
def assert_equal_dict(expected, actual):
4011
26
    assert_equal_set(
4012
27
        expected = set(expected.keys()),
4013
28
        actual = set(actual.keys())
4014
29
    )    
4015
30
    for key in expected.iterkeys():
4016
31
        try:
4017
32
            assert_equal(expected[key], actual[key])
4018
33
        except AssertionError, assertion_error:
4019
34
            raise AssertionError(
4020
35
                "[%s] %s" % (
4021
36
                    key,
4022
37
                    str(assertion_error),
4023
38
                )
4024
39
            )
4025
40
4026
41
def assert_equal_value(expected, actual):
4027
42
    assert expected == actual, "%s != %s" % (expected, actual)
4028
43
4029
44
_compare_procs = {
4030
45
    list: assert_equal_sequence,
4031
46
    int: assert_equal_value,
4032
47
    float: assert_equal_value,
4033
48
    str: assert_equal_value,
4034
49
    unicode: assert_equal_value, #sequence,
4035
50
    dict: assert_equal_dict,
4036
51
    set: assert_equal_set,
4037
52
}
4038
53
4039
54
def assert_equal(expected, actual):
4040
55
    assert_same_type(expected, actual)
4041
56
    compare_proc = _compare_procs.get(type(expected), assert_equal_value)
4042
57
    compare_proc(
4043
58
        expected,
4044
59
        actual
4045
60
    )
4046
0
61
4047
=== added file 'modules/test_utils/clear_table.py'
4048
--- modules/test_utils/clear_table.py	1970-01-01 00:00:00 +0000
4049
+++ modules/test_utils/clear_table.py	2011-09-05 13:55:13 +0000
4050
@@ -0,0 +1,4 @@
4051
1
4052
2
def clear_table(db, db_table):
4053
3
    db(db_table.id).delete()
4054
4
    db.commit()
4055
0
5
4056
=== added file 'modules/test_utils/find_JSON_format_data_structure.py'
4057
--- modules/test_utils/find_JSON_format_data_structure.py	1970-01-01 00:00:00 +0000
4058
+++ modules/test_utils/find_JSON_format_data_structure.py	2011-09-05 13:55:13 +0000
4059
@@ -0,0 +1,54 @@
4060
1
4061
2
import re
4062
3
from json.decoder import JSONDecoder
4063
4
4064
5
__all__ = (
4065
6
    "not_found",
4066
7
    "cannot_parse_JSON",
4067
8
    "find_JSON_format_data_structure"
4068
9
)
4069
10
4070
11
def not_found(name, string):
4071
12
    raise Exception(
4072
13
        u"Cannot find %s in %s" % (name, string)
4073
14
    )
4074
15
    
4075
16
def cannot_parse_JSON(string):
4076
17
    raise Exception(
4077
18
        u"Cannot parse JSON: '%s'" % string
4078
19
    )
4079
20
4080
21
def find_JSON_format_data_structure(
4081
22
    string,
4082
23
    name,
4083
24
    found,
4084
25
    not_found,
4085
26
    cannot_parse_JSON
4086
27
):
4087
28
    """Finds a named JSON-format data structure in the string.
4088
29
    
4089
30
    The name can be any string.
4090
31
    The pattern "name = " will be looked for in the string,
4091
32
        and the data structure following it parsed and returned as a python 
4092
33
        data structure. 
4093
34
    """
4094
35
    try:
4095
36
        name_start = string.index(name)
4096
37
    except ValueError:
4097
38
        not_found(name, string)
4098
39
    else:
4099
40
        name_length = len(name)
4100
41
        name_end = name_start + name_length
4101
42
        
4102
43
        _, remaining = re.Scanner([
4103
44
            (r"\s*=\s*", lambda scanner, token: None)
4104
45
        ]).scan(
4105
46
            string[name_end:]
4106
47
        )
4107
48
        
4108
49
        try:
4109
50
            data, end_position = JSONDecoder().raw_decode(remaining)
4110
51
        except ValueError, value_error:
4111
52
            cannot_parse_JSON(remaining)
4112
53
        else:
4113
54
            found(data)
4114
0
55
4115
=== modified file 'modules/test_utils/run.py'
4116
--- modules/test_utils/run.py	2011-08-11 19:25:52 +0000
4117
+++ modules/test_utils/run.py	2011-09-05 13:55:13 +0000
4118
@@ -1,5 +1,8 @@
4119
1
#!python
1
#!python
4120
2
2
4121
3
# capture web2py environment before doing anything else
4122
4
4123
5
web2py_environment = dict(globals())
4124
3
6
4125
4
__doc__ = """This script is run from the nose command in the 
7
__doc__ = """This script is run from the nose command in the 
4126
5
application being tested:
8
application being tested:
4127
@@ -8,249 +11,81 @@
4128
8
11
4129
9
python2.6 ./applications/eden/tests/nose.py <nose arguments>
12
python2.6 ./applications/eden/tests/nose.py <nose arguments>
4130
10
13
4131
14
web2py runs a file which:
4132
15
1. Sets up a plugin. This plugin registers itself so nose can use it.
4133
16
2. Runs nose programmatically giving it the plugin
4134
17
nose loads the tests via the plugin. 
4135
18
when the plugin loads the tests, it injects the web2py environment.
4136
19
4137
11
"""
20
"""
4138
12
21
4182
13
########################################
22
import sys
4183
14
#
23
4184
15
# web2py runs a file which:
24
from types import ModuleType
4142
16
# 1. Sets up a plugin. This plugin registers itself so nose can use it.
4143
17
# 2. Runs nose programmatically giving it the plugin
4144
18
#
4145
19
# nose loads the tests via the plugin. 
4146
20
# when the plugin loads the tests, it injects the web2py environment.
4147
21
#
4148
22
########################################
4149
23
4150
24
4151
25
# @ToDo:
4152
26
# in particular, haven't checked that db is being replaced with the test_db
4153
27
# (work in progress)
4154
28
4155
29
# using --import_models is OK for a single test, but for running a suite,
4156
30
# we probably need the test_env function to set up an environment
4157
31
4158
32
# @ToDo: Provide an ignore_warns mode so that we can tackle ERRORs 1st
4159
33
# but FAILs often give us clues that help us fix ERRORs
4160
34
# fixing an error might itself cause a failure, but not be spotted until later.
4161
35
4162
36
def use_test_db(db):
4163
37
    print "Creating test database..."
4164
38
    try:
4165
39
        test_db = use_test_db.db
4166
40
    except AttributeError:
4167
41
        # create test database by copying db
4168
42
        test_db_name = "sqlite://testing.sqlite"
4169
43
        print "Copying db tables into test database..."
4170
44
        test_db = DAL(test_db_name) # Name and location of the test DB file
4171
45
        # Copy tables!
4172
46
        for tablename in db.tables:
4173
47
            table_copy = []
4174
48
            for data in db[tablename]:
4175
49
                table_copy.append(
4176
50
                    copy.copy(data)
4177
51
                )
4178
52
            test_db.define_table(tablename, *table_copy)
4179
53
        use_test_db.db = test_db
4180
54
    return test_db
4181
55
4185
56
import nose
25
import nose
4187
57
26
import glob
4188
27
import os.path
4189
28
import os
4190
58
import copy
29
import copy
4219
59
def test_env(
30
from gluon.globals import Request
4220
60
    imports,
31
import unittest
4221
61
    application,
32
4222
62
    controller,
33
4223
63
    function,
34
def load_module(application_relative_module_path):
4196
64
    folder,
4197
65
    globals,
4198
66
    create_test_db = use_test_db,
4199
67
    _module_root = "applications",
4200
68
):
4201
69
    """Sets up the unit-testing environment.
4202
70
    
4203
71
    This involves loading modules as if by web2py.
4204
72
    Also we must make a test database.
4205
73
    
4206
74
    """
4207
75
    from gluon.globals import Request
4208
76
    globals["Request"] = Request
4209
77
    request = Request()
4210
78
    request.application = application
4211
79
    request.controller = controller
4212
80
    request.function = function
4213
81
    request.folder = folder
4214
82
    
4215
83
    globals["request"] = request
4216
84
4217
85
    test_db = db#create_test_db(db)
4218
86
    
4224
87
    import os
35
    import os
4244
88
    for import_path, names in imports:
36
    web2py_relative_module_path = ".".join((
4245
89
        #print import_path
37
        "applications", request.application, application_relative_module_path
4246
90
        #module = {"db": test_db}
38
    ))
4247
91
        #module.update(globals)
39
    imported_module = __import__(web2py_relative_module_path)
4248
92
        module = dict(globals)
40
    for step in web2py_relative_module_path.split(".")[1:]:
4249
93
        path_components = [_module_root] + import_path.split(".")
41
        imported_module = getattr(imported_module, step)
4250
94
        file_path = os.path.join(*path_components)+".py"
42
    return imported_module
4251
95
        # execfile is used because it doesn't create a module
43
4252
96
        # and doesn't load the module if it exists.
44
web2py_environment["load_module"] = load_module
4253
97
        execfile(file_path, module)
45
web2py_env_module = ModuleType("web2py_env")
4254
98
        if names is "*":
46
web2py_env_module.__dict__.update(web2py_environment)
4255
99
            globals.update(module)
47
sys.modules["web2py_env"] = web2py_env_module
4256
100
        else:
48
4238
101
            for name in names:
4239
102
                globals[name] = module[name]
4240
103
            
4241
104
# -----------------------
4242
105
4243
106
import os.path
4257
107
49
4258
108
application_name = request.application
50
application_name = request.application
4280
109
51
application_folder_path = os.path.join("applications",application_name)
4281
110
model_files_pattern = os.path.join("applications",application_name,"models","*.py")
52
4282
111
import glob
53
application = application_name
4283
112
54
controller = "controller"
4284
113
test_env(
55
function = "function"
4285
114
    globals = globals(),
56
folder = os.path.join(os.getcwd(), "applications", application_name)
4286
115
    application = application_name,
57
4287
116
    controller = "controller",
58
web2py_environment["Request"] = Request
4288
117
    function = "function",
59
request = Request()
4289
118
    folder = "folder",
60
request.application = application
4290
119
    imports = [
61
request.controller = controller
4291
120
        (application_name+".models.%s" % (module_name[len(model_files_pattern)-4:-3]), "*") 
62
request.function = function
4292
121
            for module_name in glob.glob(model_files_pattern)
63
request.folder = folder
4293
122
    ]
64
4294
123
)
65
web2py_environment["request"] = request
4295
124
66
current.request = request
4296
125
import sys
67
4297
126
log = sys.stderr.write
68
controller_configuration = OrderedDict()
4298
127
69
for controller_name in ["default"]+glob.glob(
4299
128
import unittest
70
    os.path.join(application_folder_path, "controllers", "*.py")
4300
129
from itertools import imap
71
):
4301
72
    controller_configuration[controller_name] = Storage(
4302
73
        name_nice = controller_name,
4303
74
        description = controller_name,
4304
75
        restricted = False,
4305
76
        module_type = 0
4306
77
    )
4307
78
    
4308
79
current.deployment_settings.modules = controller_configuration
4309
130
80
4310
131
test_folders = set()
81
test_folders = set()
4429
132
82
argv = []
4312
133
class Web2pyNosePlugin(nose.plugins.base.Plugin):
4313
134
    # see: http://somethingaboutorange.com/mrl/projects/nose/0.11.1/plugins/writing.html
4314
135
    
4315
136
    """This plugin is designed to give the web2py environment to the tests.
4316
137
    """
4317
138
    score = 0
4318
139
    # always enable as this plugin can only 
4319
140
    # be selected by running this script
4320
141
    enabled = True
4321
142
    
4322
143
    def __init__(
4323
144
        self,
4324
145
        application_name,
4325
146
        environment,
4326
147
        create_test_db,
4327
148
        directory_pattern
4328
149
    ):
4329
150
        super(Web2pyNosePlugin, self).__init__()
4330
151
        self.application_name = application_name
4331
152
        self.environment = dict(
4332
153
            db = db#create_test_db(db)
4333
154
        )
4334
155
        self.environment.update(environment)
4335
156
        self.directory_pattern = directory_pattern
4336
157
        
4337
158
    def options(self, parser, env):
4338
159
        """Register command line options"""
4339
160
        return
4340
161
        parser.add_option(
4341
162
            "--web2py",
4342
163
            dest="web2py",
4343
164
            action="append",
4344
165
            metavar="ATTR",
4345
166
            help="Use web2py environment when loading tests"
4346
167
        )
4347
168
        
4348
169
    def wantDirectory(self, dirname):
4349
170
        return bool(re.search(self.directory_pattern, dirname))
4350
171
4351
172
    def wantFile(self, file_name):
4352
173
        return file_name.endswith(".py") and any(
4353
174
            imap(file_name.__contains__, test_folders)
4354
175
        )
4355
176
4356
177
    def wantModule(self, module):
4357
178
        return False
4358
179
4359
180
    def loadTestsFromName(self, file_name, discovered):
4360
181
        """Sets up the unit-testing environment.
4361
182
        
4362
183
        This involves loading modules as if by web2py.
4363
184
        Also we must have a test database.
4364
185
        
4365
186
        If testing controllers, tests need to set up the request themselves.
4366
187
                
4367
188
        """
4368
189
        if file_name.endswith(".py"):
4369
190
#            log(file_name)
4370
191
            
4371
192
    #        assert 0, file_name
4372
193
    #        stop
4373
194
4374
195
            # Is it possible that the module could load 
4375
196
            # other code that is using the original db?
4376
197
            
4377
198
            test_globals = self.environment
4378
199
4379
200
            # execfile is used because it doesn't create a module
4380
201
            # and doesn't load the module into sys.modules if it exists.
4381
202
            module_globals = dict(self.environment)
4382
203
            execfile(file_name, module_globals)
4383
204
4384
205
            import inspect
4385
206
            # we have to return something, otherwise nose
4386
207
            # will let others have a go, and they won't pass
4387
208
            # in the web2py environment, so we'll get errors
4388
209
            tests = []
4389
210
    
4390
211
            for name, thing in module_globals.iteritems():
4391
212
                if (
4392
213
                    # don't bother with globally imported things 
4393
214
                    name not in test_globals \
4394
215
                    # unless they have been overridden
4395
216
                    or test_globals[name] is not thing
4396
217
                ):
4397
218
                    if (
4398
219
                        isinstance(thing, type)
4399
220
                        and issubclass(thing, unittest.TestCase)
4400
221
                    ):
4401
222
                        # look for test methods
4402
223
                        for member_name in dir(thing):
4403
224
                            if member_name.startswith("test"):
4404
225
                                if callable(getattr(thing, member_name)):
4405
226
                                    tests.append(thing(member_name))
4406
227
                    elif (
4407
228
                        name.startswith("test") 
4408
229
                        or name.startswith("Test")
4409
230
                    ):
4410
231
                        if inspect.isfunction(thing):
4411
232
                            function = thing
4412
233
                            function_name = name
4413
234
                            # things coming from execfile have no module
4414
235
                            #print file_name, function_name, function.__module__
4415
236
                            if function.__module__ is None:
4416
237
                                tests.append(
4417
238
                                    nose.case.FunctionTestCase(function)
4418
239
                                )
4419
240
            return tests
4420
241
        else:
4421
242
            return
4422
243
        
4423
244
import re
4424
245
4425
246
argv = [
4426
247
    #"--verbosity=2",
4427
248
    #"--debug=nose"
4428
249
]
4430
250
83
4431
251
# folder in which tests are kept
84
# folder in which tests are kept
4432
252
# non-option arguments (test paths) are made relative to this
85
# non-option arguments (test paths) are made relative to this
4434
253
test_root = os.path.join("applications", application_name, "tests", "unit_tests")
86
test_root = os.path.join(application_folder_path, "tests", "unit_tests")
4435
87
4436
88
current_working_directory = os.getcwd()
4437
254
89
4438
255
disallowed_options = {}
90
disallowed_options = {}
4439
256
disallowed_options["-w"] = disallowed_options["--where"] = (
91
disallowed_options["-w"] = disallowed_options["--where"] = (
4440
@@ -275,10 +110,10 @@
4441
275
            argv.append(arg)
110
            argv.append(arg)
4442
276
    else:
111
    else:
4443
277
        test_path = arg
112
        test_path = arg
4448
278
        test_fuller_path = os.path.join(test_root, test_path)
113
        test_folder_fuller_path = os.path.join(test_root, test_path)
4449
279
        test_folders.add(test_fuller_path)
114
        test_folders.add(test_folder_fuller_path)
4450
280
        if not os.path.exists(test_fuller_path):
115
        if not os.path.exists(test_folder_fuller_path):
4451
281
            print "\n", test_fuller_path, "not found"
116
            print "\n", test_folder_fuller_path, "not found"
4452
282
            #sys.exit(1)
117
            #sys.exit(1)
4453
283
118
4454
284
# test paths in command line aren't passed, just added to test_folders
119
# test paths in command line aren't passed, just added to test_folders
4455
@@ -293,14 +128,15 @@
4456
293
128
4457
294
sys.argv[1:] = argv
129
sys.argv[1:] = argv
4458
295
130
4459
131
test_utils = local_import("test_utils")
4460
132
4461
296
nose.main(
133
nose.main(
4462
297
# seems at least this version of nose ignores passed in argv
134
# seems at least this version of nose ignores passed in argv
4463
298
#    argv = argv, 
135
#    argv = argv, 
4464
299
    addplugins = nose.plugins.PluginManager([
136
    addplugins = nose.plugins.PluginManager([
4466
300
        Web2pyNosePlugin(
137
        test_utils.Web2pyNosePlugin(
4467
301
            application_name,
138
            application_name,
4470
302
            globals(),
139
            web2py_environment,
4469
303
            use_test_db,
4471
304
            re.compile(
140
            re.compile(
4472
305
                re.escape(os.path.sep).join(
141
                re.escape(os.path.sep).join(
4473
306
                    (
142
                    (
4474
@@ -311,7 +147,8 @@
4475
311
                        "[^","]*)*)?)?)?$"
147
                        "[^","]*)*)?)?)?$"
4476
312
                    )
148
                    )
4477
313
                )
149
                )
4479
314
            )
150
            ),
4480
151
            test_folders
4481
315
        )
152
        )
4482
316
    ])
153
    ])
4483
317
)
154
)
4484
318
155
4485
=== added file 'private/prepopulate/default/tasks.cfg'
4486
--- private/prepopulate/default/tasks.cfg	1970-01-01 00:00:00 +0000
4487
+++ private/prepopulate/default/tasks.cfg	2011-09-05 13:55:13 +0000
4488
@@ -0,0 +1,18 @@
4489
1
##########################################################################
4490
2
# Add a list of csv file to import into the system
4491
3
# the list of import file sis a comma separated list as follows:
4492
4
# "prefix","tablename","csv file name","stylesheet"
4493
5
#
4494
6
# The csv file is assumed to be in the same directory as this file
4495
7
# The style sheet is assumed to be in either of the following directories:
4496
8
#     static/format/s3csv/"prefix"/
4497
9
#     static/format/s3csv/
4498
10
#
4499
11
# For details on how to import data into the system see the following:
4500
12
#     zzz_1st_run
4501
13
#     s3Tools::S3BulkImporter
4502
14
##########################################################################
4503
15
"supply","catalog_item","DefaultItems.csv","supply_items.xsl"
4504
16
"supply","catalog_item","StandardItems.csv","supply_items.xsl"
4505
17
"hrm","skill","DefaultSkillList.csv","skill.xsl"
4506
18
"hrm","competency_rating",DefaultSkillCompetency.csv,competency_rating.xsl
4507
0
\ No newline at end of file
19
\ No newline at end of file
4508
1
20
4509
=== removed file 'private/prepopulate/default/tasks.cfg'
4510
--- private/prepopulate/default/tasks.cfg	2011-08-17 15:13:43 +0000
4511
+++ private/prepopulate/default/tasks.cfg	1970-01-01 00:00:00 +0000
4512
@@ -1,18 +0,0 @@
4513
1
##########################################################################
4514
2
# Add a list of csv file to import into the system
4515
3
# the list of import file sis a comma separated list as follows:
4516
4
# "prefix","tablename","csv file name","stylesheet"
4517
5
#
4518
6
# The csv file is assumed to be in the same directory as this file
4519
7
# The style sheet is assumed to be in either of the following directories:
4520
8
#     static/format/s3csv/"prefix"/
4521
9
#     static/format/s3csv/
4522
10
#
4523
11
# For details on how to import data into the system see the following:
4524
12
#     zzz_1st_run
4525
13
#     s3Tools::S3BulkImporter
4526
14
##########################################################################
4527
15
"supply","catalog_item","DefaultItems.csv","supply_items.xsl"
4528
16
"supply","catalog_item","StandardItems.csv","supply_items.xsl"
4529
17
"hrm","skill","DefaultSkillList.csv","skill.xsl"
4530
18
"hrm","competency_rating",DefaultSkillCompetency.csv,competency_rating.xsl
4531
19
0
4532
=== modified file 'static/scripts/S3/s3.gis.climate.js'
4533
--- static/scripts/S3/s3.gis.climate.js	2011-06-15 09:47:54 +0000
4534
+++ static/scripts/S3/s3.gis.climate.js	2011-09-05 13:55:13 +0000
4535
@@ -9,154 +9,372 @@
4536
9
    }
9
    }
4537
10
}
10
}
4538
11
11
4539
12
4540
13
ClimateDataMapPlugin = function (config) {
12
ClimateDataMapPlugin = function (config) {
4574
14
    var self = this // so no this-clobbering
13
    var plugin = this // let's be explicit!
4575
15
    self.data_type_option_names = config.data_type_option_names
14
    plugin.data_type_option_names = config.data_type_option_names
4576
16
    self.parameter_names = config.parameter_names
15
    plugin.parameter_names = config.parameter_names
4577
17
    self.projected_option_type_names = config.projected_option_type_names
16
    plugin.year_min = config.year_min 
4578
18
    self.year_min = config.year_min 
17
    plugin.year_max = config.year_max
4579
19
    self.year_max = config.year_max
18
4580
20
19
    plugin.data_type_label = config.data_type_label
4581
21
    self.data_type_label = config.data_type_label
20
    plugin.overlay_data_URL = config.overlay_data_URL
4582
22
    self.projected_option_type_label = config.projected_option_type_label
21
    plugin.chart_URL = config.chart_URL
4583
23
22
    delete config
4584
24
    self.setup = function () {        
23
4585
25
        var graphic = new OpenLayers.Layer.Image(
24
    plugin.setup = function () {
4586
26
            'Test Data',
25
        var overlay_layer = plugin.overlay_layer = new OpenLayers.Layer.Vector(
4587
27
            '/eden/climate/climate_image_overlay',
26
            'Climate data map overlay',
4588
28
            new OpenLayers.Bounds(8900000, 3020000, 9850000, 3580000),
27
            {
4589
29
//            new OpenLayers.Bounds(-180, -88.759, 180, 88.759),
28
                isBaseLayer:false,                                
4590
30
            new OpenLayers.Size(249, 139),
29
            }
4591
31
            {
30
        );
4592
32
            //    numZoomLevels: 3,
31
        map.addLayer(overlay_layer);
4593
33
                isBaseLayer:false,
32
4594
34
                opacity: 0.5,
33
        // selection
4595
35
                transparent:true
34
        OpenLayers.Feature.Vector.style['default']['strokeWidth'] = '2'
4596
36
            }
35
        var selectCtrl = new OpenLayers.Control.SelectFeature(
4597
37
        );
36
            overlay_layer,
4598
38
        graphic.events.on({
37
            {
4599
39
            loadstart: function() {
38
                clickout: true,
4600
40
                OpenLayers.Console.log("loadstart");
39
                toggle: false,
4601
41
            },
40
                multiple: false,
4602
42
            loadend: function() {
41
                hover: false,
4603
43
                OpenLayers.Console.log("loadend");
42
                toggleKey: 'altKey',
4604
44
            }
43
                multipleKey: 'shiftKey',
4605
45
        });
44
                box: true,
4606
46
        map.addLayer(graphic);
45
                onSelect: function (feature) {
4607
46
                    feature.style.strokeColor = 'black'
4608
47
                    feature.style.strokeDashstyle = 'dash'
4609
48
                    overlay_layer.drawFeature(feature)
4610
49
                },
4611
50
                onUnselect: function (feature) {
4612
51
                    feature.style.strokeColor = 'none'
4613
52
                    overlay_layer.drawFeature(feature)
4614
53
                },
4615
54
            }
4616
55
        );
4617
56
        
4618
57
        map.addControl(selectCtrl);
4619
58
4620
59
        selectCtrl.activate();
4621
47
    }
60
    }
4626
48
    self.addToMapWindow = function (items) {
61
    plugin.addToMapWindow = function (items) {
4627
49
        function toggle_projected_options() {
62
        var combo_box_size = {
4628
50
            $('#projected-options').toggle(
63
            width: 120,
4629
51
                $('#id_Projected').attr('checked') == 'checked'
64
            heigth:25
4630
65
        }
4631
66
4632
67
        function make_combo_box(
4633
68
            data,
4634
69
            fieldLabel,
4635
70
            hiddenName
4636
71
        ) {
4637
72
            var options = []
4638
73
            each(
4639
74
                data,
4640
75
                function (option) {
4641
76
                    options.push([option, option])
4642
77
                }
4643
52
            )
78
            )
4727
53
        }
79
            var combo_box = new Ext.form.ComboBox({
4728
54
        var climate_data_type_options = [];
80
                fieldLabel: fieldLabel,
4729
55
        each(
81
                hiddenName: hiddenName,
4730
56
            self.data_type_option_names,
82
                store: new Ext.data.SimpleStore({
4731
57
            function (option_name) {
83
                    fields: ['name', 'option'],
4732
58
                var radio_button = new Ext.form.Radio({
84
                    data: options
4650
59
                    name: "data-type",
4651
60
                    id: "id_%s" % option_name,
4652
61
                    boxLabel: option_name,
4653
62
                    checked: option_name == self.data_type_option_names[0],
4654
63
                })
4655
64
                radio_button.on({
4656
65
                    change: toggle_projected_options
4657
66
                })
4658
67
                climate_data_type_options.push(radio_button)
4659
68
            }
4660
69
        )
4661
70
        var projected_options = [];
4662
71
        each(
4663
72
            self.projected_option_type_names,
4664
73
            function (projected_option_type_name) {
4665
74
                projected_options.push(
4666
75
                    new Ext.form.Radio({
4667
76
                        name: "projected-option-type",
4668
77
                        id: "id_%s" % projected_option_type_name,
4669
78
                        boxLabel: projected_option_type_name,
4670
79
                    })
4671
80
                )
4672
81
            }
4673
82
        )
4674
83
        var projected_options_widget = new Ext.form.FieldSet({
4675
84
            title: self.projected_option_type_label,
4676
85
            items: [
4677
86
                new Ext.form.CheckboxGroup({
4678
87
                    items: projected_options,
4679
88
                    xtype: 'checkboxgroup',
4680
89
                    columns: 1
4681
90
                })
4682
91
            ]
4683
92
        })
4684
93
4685
94
        var climate_data_type_options = new Ext.form.FieldSet({
4686
95
            title: self.data_type_label,
4687
96
            items: [
4688
97
                new Ext.form.RadioGroup({
4689
98
                    items: climate_data_type_options,
4690
99
                    columns: 1,
4691
100
                })
4692
101
            ]
4693
102
        })
4694
103
        
4695
104
        var parameter_options = [];
4696
105
        each(
4697
106
            self.parameter_names,
4698
107
            function (parameter_name) {
4699
108
                var checkbox = new Ext.form.Checkbox({
4700
109
                    name: parameter_name,
4701
110
                    id: "id_%s" % parameter_name,
4702
111
                    boxLabel: parameter_name,
4703
112
                })
4704
113
                parameter_options.push(checkbox)
4705
114
            }
4706
115
        )
4707
116
4708
117
        var parameters_widget = new Ext.form.FieldSet({
4709
118
            title: "Parameters",
4710
119
            items: [
4711
120
                new Ext.form.CheckboxGroup({
4712
121
                    items: parameter_options,
4713
122
                    xtype: 'checkboxgroup',
4714
123
                    columns: 1
4715
124
                })
4716
125
            ]
4717
126
        })
4718
127
        
4719
128
        var period_widget = new Ext.form.FieldSet({
4720
129
            title: "Period",
4721
130
            items: [
4722
131
                new Ext.form.NumberField({
4723
132
                    fieldLabel: "From",
4724
133
                    minValue: self.year_min,
4725
134
                    maxValue: self.year_max,
4726
135
                    value: self.year_min
4733
136
                }),
85
                }),
4742
137
                new Ext.form.NumberField({
86
                displayField: 'name',
4743
138
                    fieldLabel: "To",
87
                typeAhead: true,
4744
139
                    minValue: self.year_min,
88
                mode: 'local',
4745
140
                    maxValue: self.year_max,
89
                triggerAction: 'all',
4746
141
                    value: self.year_max
90
                emptyText:'Choose...',
4747
142
                })
91
                selectOnFocus:true
4748
143
            ]
92
            })
4749
144
        })
93
            combo_box.setSize(combo_box_size)
4750
94
            return combo_box
4751
95
        }
4752
96
        var data_type_combo_box = make_combo_box(
4753
97
            plugin.data_type_option_names,
4754
98
            'Data type',
4755
99
            'data_type'
4756
100
        )
4757
101
4758
102
        var variable_combo_box = make_combo_box(
4759
103
            plugin.parameter_names,
4760
104
            'Variable',
4761
105
            'parameter'
4762
106
        )
4763
107
        
4764
108
        var statistic_combo_box = make_combo_box(
4765
109
            ['Minimum','Maximum','Average'],
4766
110
            'Aggregate values',
4767
111
            'statistic'
4768
112
        )
4769
113
                        
4770
145
        var climate_data_panel = new Ext.FormPanel({
114
        var climate_data_panel = new Ext.FormPanel({
4771
146
            id: 'climate_data_panel',
115
            id: 'climate_data_panel',
4773
147
            title: 'Climate data',
116
            title: 'Climate data map overlay',
4774
148
            collapsible: true,
117
            collapsible: true,
4775
149
            collapseMode: 'mini',
118
            collapseMode: 'mini',
4776
150
            items: [{
119
            items: [{
4777
151
                region: 'center',
120
                region: 'center',
4778
152
                items: [
121
                items: [
4783
153
                    climate_data_type_options,
122
                    new Ext.form.FieldSet({
4784
154
                    projected_options_widget,
123
                        title: 'Data set',
4785
155
                    parameters_widget,
124
                        items: [
4786
156
                    period_widget
125
                            data_type_combo_box,
4787
126
                            variable_combo_box
4788
127
                        ]
4789
128
                    }),
4790
129
                    new Ext.form.FieldSet({
4791
130
                        title: 'Period',
4792
131
                        items: [
4793
132
                            new Ext.form.NumberField({
4794
133
                                fieldLabel: 'From',
4795
134
                                name: 'from_date',
4796
135
                                minValue: plugin.year_min,
4797
136
                                maxValue: plugin.year_max,
4798
137
                                value: plugin.year_min
4799
138
                            }),
4800
139
                            new Ext.form.NumberField({
4801
140
                                fieldLabel: 'To',
4802
141
                                name: 'to_date',
4803
142
                                minValue: plugin.year_min,
4804
143
                                maxValue: plugin.year_max,
4805
144
                                value: plugin.year_max,
4806
145
                                size: combo_box_size
4807
146
                            })
4808
147
                        ]
4809
148
                    }),
4810
149
                    new Ext.form.FieldSet({
4811
150
                        title: 'Map overlay colours',
4812
151
                        items: [
4813
152
                            statistic_combo_box,
4814
153
                        ]
4815
154
                    })
4816
157
                ]
155
                ]
4817
158
            }]
156
            }]
4818
159
        });
157
        });
4819
158
                
4820
159
        var update_map_layer_button = new Ext.Button({
4821
160
            text: 'Update map layer',
4822
161
            disabled: true,
4823
162
            handler: function() {
4824
163
                plugin.overlay_layer.destroyFeatures()
4825
164
                
4826
165
                // request new features
4827
166
                var form_values = climate_data_panel.getForm().getValues()
4828
167
                
4829
168
                // add new features
4830
169
                $.ajax({
4831
170
                    url: plugin.overlay_data_URL,
4832
171
                    data: {
4833
172
                        data_type: form_values.data_type,
4834
173
                        statistic: form_values.statistic,
4835
174
                        parameter: form_values.parameter,
4836
175
                        from_date: form_values.from_date,
4837
176
                        to_date: form_values.to_date
4838
177
                    },
4839
178
                    success: function(feature_data, status_code) {
4840
179
                        function Vector(geometry, attributes, style) {
4841
180
                            style.strokeColor= 'none'
4842
181
                            style.fillOpacity= 0.8
4843
182
                            style.strokeWidth = 1
4844
183
4845
184
                            return new OpenLayers.Feature.Vector(
4846
185
                                geometry, attributes, style
4847
186
                            )
4848
187
                        }
4849
188
                        function Polygon(components) {
4850
189
                            return new OpenLayers.Geometry.Polygon(components)
4851
190
                        }
4852
191
                        function Point(lon, lat) {
4853
192
                            var point = new OpenLayers.Geometry.Point(lat, lon)
4854
193
                            return point.transform(
4855
194
                                S3.gis.proj4326,
4856
195
                                S3.gis.projection_current
4857
196
                            )
4858
197
                        }
4859
198
                        function LinearRing(point_list) {
4860
199
                            point_list.push(point_list[0])
4861
200
                            return new OpenLayers.Geometry.LinearRing(point_list)
4862
201
                        }
4863
202
                        eval('var data = '+feature_data)
4864
203
                        $('#id_key_min_value').html(data.min)
4865
204
                        $('#id_key_max_value').html(data.max)
4866
205
                        plugin.overlay_layer.addFeatures(data.features)
4867
206
                    }
4868
207
                });
4869
208
            }
4870
209
        });
4871
210
4872
211
        function enable_update_layer_button_if_form_complete(
4873
212
            box, record, index
4874
213
        ) {
4875
214
            if (
4876
215
                !!data_type_combo_box.getValue() &&
4877
216
                !!variable_combo_box.getValue() &&
4878
217
                !!statistic_combo_box.getValue()
4879
218
            ) {
4880
219
                update_map_layer_button.enable()
4881
220
            }
4882
221
        }
4883
222
        data_type_combo_box.on(
4884
223
            'change',
4885
224
            enable_update_layer_button_if_form_complete
4886
225
        );
4887
226
        variable_combo_box.on(
4888
227
            'change',
4889
228
            enable_update_layer_button_if_form_complete
4890
229
        );
4891
230
        statistic_combo_box.on(
4892
231
            'change',
4893
232
            enable_update_layer_button_if_form_complete
4894
233
        );
4895
234
        climate_data_panel.addButton(update_map_layer_button)
4896
235
        
4897
236
        var show_chart_button = new Ext.Button({
4898
237
            text: 'Show chart',
4899
238
            disabled: true,
4900
239
            handler: function() {
4901
240
                // create URL
4902
241
                var place_ids = []
4903
242
                each(
4904
243
                    plugin.overlay_layer.selectedFeatures, 
4905
244
                    function (feature) {
4906
245
                        place_ids.push(feature.data.id)
4907
246
                    }
4908
247
                )
4909
248
                var form_values = climate_data_panel.getForm().getValues(),
4910
249
                    data_type = form_values.data_type,
4911
250
                    parameter = form_values.parameter,
4912
251
                    from_date = form_values.from_date,
4913
252
                    to_date = form_values.to_date,
4914
253
                    place_ids = place_ids;
4915
254
                
4916
255
                var spec = JSON.stringify({
4917
256
                    data_type: data_type,
4918
257
                    parameter: parameter,
4919
258
                    from_date: from_date,
4920
259
                    to_date: to_date,
4921
260
                    place_ids: place_ids
4922
261
                })
4923
262
                
4924
263
                var chart_name = [
4925
264
                    data_type, parameter,
4926
265
                    'from', from_date,
4927
266
                    'to', to_date,
4928
267
                    'for', (
4929
268
                        place_ids.length < 3?
4930
269
                        'places: '+ place_ids:
4931
270
                        place_ids.length+' places'
4932
271
                    )
4933
272
                ].join(' ')
4934
273
4935
274
                // get hold of a chart manager instance
4936
275
                if (!plugin.chart_window) {
4937
276
                    var chart_window = plugin.chart_window = window.open(
4938
277
                        'climate/chart_popup.html',
4939
278
                        'chart', 
4940
279
                        'width=660,height=600,toolbar=0,resizable=0'
4941
280
                    )
4942
281
                    chart_window.onload = function () {
4943
282
                        chart_window.chart_manager = new chart_window.ChartManager(plugin.chart_URL)
4944
283
                        chart_window.chart_manager.addChartSpec(spec, chart_name)
4945
284
                    }
4946
285
                    chart_window.onbeforeunload = function () {
4947
286
                        delete plugin.chart_window
4948
287
                    }
4949
288
                } else {
4950
289
                    // some duplication here:
4951
290
                    plugin.chart_window. chart_manager.addChartSpec(spec, chart_name)
4952
291
                }
4953
292
                
4954
293
            }
4955
294
        });
4956
295
        
4957
296
        
4958
297
        function enable_show_chart_button_if_data_and_variable_selected(
4959
298
            box, record, index
4960
299
        ) {
4961
300
            if (
4962
301
                !!data_type_combo_box.getValue() &&
4963
302
                !!variable_combo_box.getValue()
4964
303
            ) {
4965
304
                show_chart_button.enable()
4966
305
            }
4967
306
        }
4968
307
        
4969
308
        data_type_combo_box.on(
4970
309
            'change',
4971
310
            enable_show_chart_button_if_data_and_variable_selected
4972
311
        );
4973
312
        
4974
313
        variable_combo_box.on(
4975
314
            'change',
4976
315
            enable_show_chart_button_if_data_and_variable_selected
4977
316
        );
4978
317
4979
318
4980
319
        
4981
320
        climate_data_panel.addButton(show_chart_button)
4982
321
        
4983
160
        items.push(climate_data_panel)
322
        items.push(climate_data_panel)
4984
323
        
4985
324
        var key_panel = new Ext.Panel({
4986
325
            id: 'key_panel',
4987
326
            title: 'Key',
4988
327
            collapsible: true,
4989
328
            collapseMode: 'mini',
4990
329
            items: [
4991
330
                {
4992
331
                    layout: {
4993
332
                        type: 'table',
4994
333
                        columns: 3,
4995
334
                    },
4996
335
                    defaults: {
4997
336
                        width: '100%',
4998
337
                        height: 20,
4999
338
                        style: 'margin: 10px'
5000
339
                    },
Status:	Superseded
Proposed branch:	lp:~mike-amy/sahana-eden/climate
Merge into:	lp:sahana-eden
Diff against target:	7765 lines (+3996/-2732) 55 files modified controllers/climate.py (+159/-96) deployment-templates/models/000_config.py (+1/-1) models/03_gis.py (+2/-0) models/climate.py (+5/-0) modules/ClimateDataPortal/MapPlugin.py (+430/-0) modules/ClimateDataPortal/__init__.py (+201/-0) modules/ClimateDataPortal/import_NetCDF_readings.py (+131/-0) modules/ClimateDataPortal/import_stations.py (+53/-0) modules/ClimateDataPortal/import_tabbed_readings.py (+154/-0) modules/s3/s3gis.py (+784/-1031) modules/test_utils/AddedRole.py (+25/-0) modules/test_utils/Change.py (+25/-0) modules/test_utils/ExpectSessionWarning.py (+14/-0) modules/test_utils/ExpectedException.py (+13/-0) modules/test_utils/InsertedRecord.py (+19/-0) modules/test_utils/Web2pyNosePlugin.py (+106/-0) modules/test_utils/__init__.py (+11/-1) modules/test_utils/assert_equal.py (+60/-0) modules/test_utils/clear_table.py (+4/-0) modules/test_utils/find_JSON_format_data_structure.py (+54/-0) modules/test_utils/run.py (+76/-239) private/prepopulate/default/tasks.cfg (+0/-18) static/scripts/S3/s3.gis.climate.js (+352/-134) tests/climate/__init__.py (+101/-0) tests/nose.py (+2/-2) tests/unit_tests/gis/basic_map.html (+0/-91) tests/unit_tests/gis/bing.html (+0/-62) tests/unit_tests/gis/feature_queries.html (+0/-52) tests/unit_tests/gis/google.html (+0/-67) tests/unit_tests/gis/map_with_layers.html (+0/-150) tests/unit_tests/gis/s3gis.py (+0/-417) tests/unit_tests/gis/testgis.cmd (+0/-8) tests/unit_tests/gis/true_code_paths.html (+0/-302) tests/unit_tests/gis/yahoo.html (+0/-61) tests/unit_tests/modules/s3/s3gis/BingLayer.py (+28/-0) tests/unit_tests/modules/s3/s3gis/CommonScripts.py (+47/-0) tests/unit_tests/modules/s3/s3gis/FeatureLayer.py (+25/-0) tests/unit_tests/modules/s3/s3gis/FeatureQueries.py (+44/-0) tests/unit_tests/modules/s3/s3gis/GPXLayer.py (+29/-0) tests/unit_tests/modules/s3/s3gis/GeoJSONLayer.py (+28/-0) tests/unit_tests/modules/s3/s3gis/GeoRSSLayer.py (+74/-0) tests/unit_tests/modules/s3/s3gis/GoogleLayer.py (+84/-0) tests/unit_tests/modules/s3/s3gis/KMLLayer.py (+54/-0) tests/unit_tests/modules/s3/s3gis/LayerFailures.py (+117/-0) tests/unit_tests/modules/s3/s3gis/OpenStreetMap.py (+31/-0) tests/unit_tests/modules/s3/s3gis/TMSLayer.py (+30/-0) tests/unit_tests/modules/s3/s3gis/TrueCodePaths.py (+307/-0) tests/unit_tests/modules/s3/s3gis/UserInterface.py (+7/-0) tests/unit_tests/modules/s3/s3gis/WFSLayer.py (+31/-0) tests/unit_tests/modules/s3/s3gis/WMSLayer.py (+28/-0) tests/unit_tests/modules/s3/s3gis/YahooLayer.py (+48/-0) tests/unit_tests/modules/s3/s3gis/__init__.py (+68/-0) tests/unit_tests/modules/s3/s3rest.py (+6/-0) tests/unit_tests/modules/test_utils/find_JSON_format_data_structure.py (+52/-0) views/climate/chart_popup.html (+76/-0)
To merge this branch:	bzr merge lp:~mike-amy/sahana-eden/climate
Related bugs:	Link a bug report
Reviewer	Review Type	Date Requested	Status
Fran Boon		2011-09-05	Needs Fixing on 2011-09-05
Review via email: mp+74043@code.launchpad.net