desc
stringlengths 3
26.7k
| decl
stringlengths 11
7.89k
| bodies
stringlengths 8
553k
|
|---|---|---|
'Remove all the permissions except for the owner and assign the
view permission to the anonymous group'
| def set_default_permissions(self):
| remove_object_permissions(self)
(anonymous_group, created) = Group.objects.get_or_create(name='anonymous')
if (not anonymous_group):
raise Exception("Could not acquire 'anonymous' Group.")
if settings.DEFAULT_ANONYMOUS_VIEW_PERMISSION:
assign_perm('view_resourcebase', anonymous_group, self.get_self_resource())
set_geofence_all(self)
if settings.DEFAULT_ANONYMOUS_DOWNLOAD_PERMISSION:
assign_perm('download_resourcebase', anonymous_group, self.get_self_resource())
set_owner_permissions(self)
if (self.__class__.__name__ == 'Layer'):
assign_perm('change_layer_data', self.owner, self)
assign_perm('change_layer_style', self.owner, self)
|
'Sets an object\'s the permission levels based on the perm_spec JSON.
the mapping looks like:
\'users\': {
\'AnonymousUser\': [\'view\'],
<username>: [\'perm1\',\'perm2\',\'perm3\'],
<username2>: [\'perm1\',\'perm2\',\'perm3\']
\'groups\': [
<groupname>: [\'perm1\',\'perm2\',\'perm3\'],
<groupname2>: [\'perm1\',\'perm2\',\'perm3\'],'
| def set_permissions(self, perm_spec):
| remove_object_permissions(self)
if (('users' in perm_spec) and ('AnonymousUser' in perm_spec['users'])):
anonymous_group = Group.objects.get(name='anonymous')
for perm in perm_spec['users']['AnonymousUser']:
if ((self.polymorphic_ctype.name == 'layer') and (perm in ('change_layer_data', 'change_layer_style', 'add_layer', 'change_layer', 'delete_layer'))):
assign_perm(perm, anonymous_group, self.layer)
else:
assign_perm(perm, anonymous_group, self.get_self_resource())
if ('users' in perm_spec):
for (user, perms) in perm_spec['users'].items():
user = get_user_model().objects.get(username=user)
for perm in perms:
if ((self.polymorphic_ctype.name == 'layer') and (perm in ('change_layer_data', 'change_layer_style', 'add_layer', 'change_layer', 'delete_layer'))):
assign_perm(perm, user, self.layer)
else:
assign_perm(perm, user, self.get_self_resource())
has_view_perms = ('view_resourcebase' in perms)
has_download_perms = ('download_resourcebase' in perms)
geofence_user = str(user)
if ('AnonymousUser' in geofence_user):
geofence_user = None
set_geofence_owner(self, geofence_user, view_perms=has_view_perms, download_perms=has_download_perms)
if ('groups' in perm_spec):
for (group, perms) in perm_spec['groups'].items():
group = Group.objects.get(name=group)
for perm in perms:
if ((self.polymorphic_ctype.name == 'layer') and (perm in ('change_layer_data', 'change_layer_style', 'add_layer', 'change_layer', 'delete_layer'))):
assign_perm(perm, group, self.layer)
else:
assign_perm(perm, group, self.get_self_resource())
has_view_perms = ('view_resourcebase' in perms)
has_download_perms = ('download_resourcebase' in perms)
set_geofence_group(self, str(group), view_perms=has_view_perms, download_perms=has_download_perms)
set_owner_permissions(self)
|
'Test that after restrict view permissions on two layers
bobby is unable to see them'
| def test_set_bulk_permissions(self):
| layers = Layer.objects.all()[:2].values_list('id', flat=True)
layers_id = map((lambda x: str(x)), layers)
self.client.login(username='admin', password='admin')
resp = self.client.get(self.list_url)
self.assertEquals(len(self.deserialize(resp)['objects']), 8)
data = {'permissions': json.dumps(self.perm_spec), 'resources': layers_id}
resp = self.client.post(self.bulk_perms_url, data)
self.assertHttpOK(resp)
self.client.logout()
self.client.login(username='bobby', password='bob')
resp = self.client.get(self.list_url)
self.assertEquals(len(self.deserialize(resp)['objects']), 6)
|
'Test that Bobby can set the permissions only only on the ones
for which he has the right'
| def test_bobby_cannot_set_all(self):
| layer = Layer.objects.all()[0]
self.client.login(username='admin', password='admin')
assign_perm('change_resourcebase', Profile.objects.get(username='bobby'), layer.get_self_resource())
self.client.logout()
self.client.login(username='bobby', password='bob')
layer2 = Layer.objects.all()[1]
data = {'permissions': json.dumps({'users': {'bobby': ['view_resourcebase']}, 'groups': {}}), 'resources': [layer.id, layer2.id]}
resp = self.client.post(self.bulk_perms_url, data)
self.assertTrue((layer2.title in json.loads(resp.content)['not_changed']))
|
'Verify that Layer.set_default_permissions is behaving as expected'
| def test_layer_set_default_permissions(self):
| layer = Layer.objects.all()[0]
layer.set_default_permissions()
self.assertTrue(self.anonymous_user.has_perm('view_resourcebase', layer.get_self_resource()))
self.assertTrue(layer.owner.has_perm('view_resourcebase', layer.get_self_resource()))
self.assertTrue(layer.owner.has_perm('download_resourcebase', layer.get_self_resource()))
self.assertTrue(layer.owner.has_perm('change_resourcebase_metadata', layer.get_self_resource()))
if (layer.storeType == 'dataStore'):
self.assertTrue(layer.owner.has_perm('change_layer_data', layer))
self.assertTrue(layer.owner.has_perm('change_layer_style', layer))
self.assertTrue(layer.owner.has_perm('change_resourcebase', layer.get_self_resource()))
self.assertTrue(layer.owner.has_perm('delete_resourcebase', layer.get_self_resource()))
self.assertTrue(layer.owner.has_perm('change_resourcebase_permissions', layer.get_self_resource()))
self.assertTrue(layer.owner.has_perm('publish_resourcebase', layer.get_self_resource()))
|
'Verify that the set_layer_permissions view is behaving as expected'
| def test_set_layer_permissions(self):
| layer = Layer.objects.all()[0]
layer.set_permissions(self.perm_spec)
self.assertFalse(self.anonymous_user.has_perm('view_resourcebase', layer.get_self_resource()))
current_perms = layer.get_all_level_info()
self.assertEqual(len(current_perms['users'].keys()), 2)
for (username, perm) in self.perm_spec['users'].items():
user = get_user_model().objects.get(username=username)
self.assertTrue(user.has_perm(perm, layer.get_self_resource()))
|
'Verify that the ajax_layer_permissions view is behaving as expected'
| def test_ajax_layer_permissions(self):
| valid_layer_typename = Layer.objects.all()[0].id
invalid_layer_id = 9999999
response = self.client.post(reverse('resource_permissions', args=(invalid_layer_id,)), data=json.dumps(self.perm_spec), content_type='application/json')
self.assertEquals(response.status_code, 404)
response = self.client.get(reverse('resource_permissions', args=(valid_layer_typename,)))
assert ('permissions' in response.content)
response = self.client.post(reverse('resource_permissions', args=(valid_layer_typename,)), data=json.dumps(self.perm_spec), content_type='application/json')
self.assertEquals(response.status_code, 401)
logged_in = self.client.login(username='bobby', password='bob')
self.assertEquals(logged_in, True)
response = self.client.post(reverse('resource_permissions', args=(valid_layer_typename,)), data=json.dumps(self.perm_spec), content_type='application/json')
self.assertEquals(response.status_code, 401)
logged_in = self.client.login(username='admin', password='admin')
self.assertEquals(logged_in, True)
response = self.client.post(reverse('resource_permissions', args=(valid_layer_typename,)), data=json.dumps(self.perm_spec), content_type='application/json')
self.assertEquals(response.status_code, 200)
|
'Verify that the perms_info view is behaving as expected'
| def test_perms_info(self):
| layer = Layer.objects.all()[0]
layer.set_default_permissions()
self.assertTrue(self.anonymous_user.has_perm('view_resourcebase', layer.get_self_resource()))
self.assertTrue(layer.owner.has_perm('change_resourcebase', layer.get_self_resource()))
|
'Test the correct permissions on layers on map download'
| def test_map_download(self):
| create_models(type='map')
create_maplayers()
the_map = Map.objects.get(title='GeoNode Default Map')
map_layer = the_map.layer_set.get(name='geonode:CA')
map_layer.local = True
map_layer.group = 'overlay'
map_layer.save()
the_map.layer_set.all().delete()
the_map.layer_set.add(map_layer)
bobby = Profile.objects.get(username='bobby')
the_layer = Layer.objects.get(alternate='geonode:CA')
remove_perm('download_resourcebase', bobby, the_layer.get_self_resource())
remove_perm('download_resourcebase', Group.objects.get(name='anonymous'), the_layer.get_self_resource())
assign_perm('view_resourcebase', bobby, the_layer.get_self_resource())
assign_perm('download_resourcebase', bobby, the_map.get_self_resource())
self.client.login(username='bobby', password='bob')
response = self.client.get(reverse('map_download', args=(the_map.id,)))
self.assertTrue(('Could not find downloadable layers for this map' in response.content))
|
'If PROXY_ALLOWED_HOSTS is empty and DEBUG is True, all hosts pass the proxy.'
| @override_settings(DEBUG=True, PROXY_ALLOWED_HOSTS=())
def test_validate_host_disabled_in_debug(self):
| response = self.client.get(('/proxy?url=%s' % self.url), follow=True)
self.assertEqual(response.status_code, 200)
|
'If PROXY_ALLOWED_HOSTS is empty and DEBUG is False requests should return 403.'
| @override_settings(DEBUG=False, PROXY_ALLOWED_HOSTS=())
def test_validate_host_disabled_not_in_debug(self):
| response = self.client.get(('/proxy?url=%s' % self.url), follow=True)
self.assertEqual(response.status_code, 403)
|
'If PROXY_ALLOWED_HOSTS is empty and DEBUG is False requests should return 403.'
| @override_settings(DEBUG=False, PROXY_ALLOWED_HOSTS=('.google.com',))
@override_settings(DEBUG=False, PROXY_ALLOWED_HOSTS=(TEST_DOMAIN,))
def test_proxy_allowed_host(self):
| response = self.client.get(('/proxy?url=%s' % self.url), follow=True)
self.assertEqual(response.status_code, 200)
|
'Scan layers xml and see if there are external references.
Find references to data outside data dir and include them in
backup. Also, some references may point to specific url, which
may not be available later.'
| def dump_geoserver_externals(self, config, settings, target_folder):
| external_folder = os.path.join(target_folder, helpers.EXTERNAL_ROOT)
def copy_external_resource(abspath):
external_path = os.path.join(external_folder, abspath[1:])
external_dir = os.path.dirname(external_path)
if (not os.path.isdir(external_dir)):
os.makedirs(external_dir)
shutil.copy(abspath, external_path)
def match_filename(key, text, regexp=re.compile('^(.+)$')):
if (key in ('filename',)):
match = regexp.match(text)
if match:
relpath = match.group(1)
abspath = (relpath if os.path.isabs(relpath) else os.path.abspath(os.path.join(os.path.dirname(path), relpath)))
if os.path.exists(abspath):
return abspath
def match_fileurl(key, text, regexp=re.compile('^file:(.+)$')):
if (key in ('url',)):
match = regexp.match(text)
if match:
relpath = match.group(1)
abspath = (relpath if os.path.isabs(relpath) else os.path.abspath(os.path.join(config.gs_data_dir, relpath)))
if os.path.exists(abspath):
return abspath
def dump_external_resources_from_xml(path):
def find_external(tree, key=None):
if isinstance(tree, dict):
for (key, value) in tree.iteritems():
for found in find_external(value, key=key):
(yield found)
elif isinstance(tree, list):
for item in tree:
for found in find_external(item, key=key):
(yield found)
elif isinstance(tree, unicode):
text = tree.encode('utf-8')
for find in (match_fileurl, match_filename):
found = find(key, text)
if found:
(yield found)
with open(path) as fd:
content = fd.read()
tree = parse_xml(content)
for found in find_external(tree):
if (found.find(config.gs_data_dir) != 0):
copy_external_resource(found)
def is_xml_file(filename, regexp=re.compile('.*.xml$')):
return (regexp.match(filename) is not None)
for directory in ('workspaces', 'styles'):
source = os.path.join(config.gs_data_dir, directory)
for (root, dirs, files) in os.walk(source):
for filename in filter(is_xml_file, files):
path = os.path.join(root, filename)
dump_external_resources_from_xml(path)
|
'json_string is basicly string that you give to json.loads method'
| def decode(self, json_string):
| default_obj = super(DefaultMangler, self).decode(json_string)
for obj in default_obj:
obj['pk'] = (obj['pk'] + self.basepk)
return default_obj
|
'json_string is basicly string that you give to json.loads method'
| def decode(self, json_string):
| default_obj = super(ResourceBaseMangler, self).decode(json_string)
upload_sessions = []
for obj in default_obj:
obj['pk'] = (obj['pk'] + self.basepk)
obj['fields']['owner'] = [self.owner]
if ('distribution_url' in obj['fields']):
if ((not (obj['fields']['distribution_url'] is None)) and ('layers' in obj['fields']['distribution_url'])):
try:
p = '(?P<protocol>http.*://)?(?P<host>[^:/ ]+).?(?P<port>[0-9]*)(?P<details_url>.*)'
m = re.search(p, obj['fields']['distribution_url'])
if ('http' in m.group('protocol')):
obj['fields']['detail_url'] = (self.siteurl + m.group('details_url'))
else:
obj['fields']['detail_url'] = (self.siteurl + obj['fields']['distribution_url'])
except:
obj['fields']['detail_url'] = obj['fields']['distribution_url']
upload_sessions.append(self.add_upload_session(obj['pk'], obj['fields']['owner']))
default_obj.extend(upload_sessions)
return default_obj
|
'json_string is basicly string that you give to json.loads method'
| def decode(self, json_string):
| default_obj = super(LayerMangler, self).decode(json_string)
for obj in default_obj:
obj['pk'] = (obj['pk'] + self.basepk)
obj['fields']['upload_session'] = obj['pk']
obj['fields']['service'] = None
if self.datastore:
obj['fields']['store'] = self.datastore
else:
obj['fields']['store'] = obj['fields']['name']
return default_obj
|
'json_string is basicly string that you give to json.loads method'
| def decode(self, json_string):
| default_obj = super(LayerAttributesMangler, self).decode(json_string)
for obj in default_obj:
obj['pk'] = (obj['pk'] + self.basepk)
obj['fields']['layer'] = (obj['fields']['layer'] + self.basepk)
return default_obj
|
'json_string is basicly string that you give to json.loads method'
| def decode(self, json_string):
| default_obj = super(MapLayersMangler, self).decode(json_string)
for obj in default_obj:
obj['pk'] = (obj['pk'] + self.basepk)
obj['fields']['map'] = (obj['fields']['map'] + self.basepk)
return default_obj
|
'json_string is basicly string that you give to json.loads method'
| def decode(self, json_string):
| default_obj = super(DefaultMangler, self).decode(json_string)
return default_obj
|
'json_string is basicly string that you give to json.loads method'
| def decode(self, json_string):
| default_obj = super(ResourceBaseMangler, self).decode(json_string)
upload_sessions = []
for obj in default_obj:
obj['pk'] = (obj['pk'] + self.basepk)
obj['fields']['featured'] = False
obj['fields']['rating'] = 0
obj['fields']['popular_count'] = 0
obj['fields']['share_count'] = 0
obj['fields']['is_published'] = True
obj['fields']['thumbnail_url'] = ''
if ('distribution_url' in obj['fields']):
if ((not (obj['fields']['distribution_url'] is None)) and ('layers' in obj['fields']['distribution_url'])):
obj['fields']['polymorphic_ctype'] = ['layers', 'layer']
try:
p = '(?P<protocol>http.*://)?(?P<host>[^:/ ]+).?(?P<port>[0-9]*)(?P<details_url>.*)'
m = re.search(p, obj['fields']['distribution_url'])
if ('http' in m.group('protocol')):
obj['fields']['detail_url'] = (self.siteurl + m.group('details_url'))
else:
obj['fields']['detail_url'] = (self.siteurl + obj['fields']['distribution_url'])
except:
obj['fields']['detail_url'] = obj['fields']['distribution_url']
else:
obj['fields']['polymorphic_ctype'] = ['maps', 'map']
try:
obj['fields'].pop('distribution_description', None)
except:
pass
try:
obj['fields'].pop('distribution_url', None)
except:
pass
try:
obj['fields'].pop('thumbnail', None)
except:
pass
upload_sessions.append(self.add_upload_session(obj['pk'], obj['fields']['owner']))
default_obj.extend(upload_sessions)
return default_obj
|
'json_string is basicly string that you give to json.loads method'
| def decode(self, json_string):
| default_obj = super(LayerMangler, self).decode(json_string)
for obj in default_obj:
obj['pk'] = (obj['pk'] + self.basepk)
from geonode.base.models import ResourceBase
resource = ResourceBase.objects.get(pk=obj['pk'])
obj['fields']['upload_session'] = obj['pk']
obj['fields']['service'] = None
obj['fields']['charset'] = 'UTF-8'
obj['fields']['title_en'] = resource.title
obj['fields']['data_quality_statement_en'] = ''
obj['fields']['regions'] = []
obj['fields']['supplemental_information_en'] = 'No information provided'
obj['fields']['abstract_en'] = 'No abstract provided'
obj['fields']['purpose_en'] = ''
obj['fields']['constraints_other_en'] = ''
obj['fields']['default_style'] = None
if self.datastore:
obj['fields']['store'] = self.datastore
else:
obj['fields']['store'] = obj['fields']['name']
try:
obj['fields'].pop('popular_count', None)
except:
pass
try:
obj['fields'].pop('share_count', None)
except:
pass
try:
obj['fields'].pop('title', None)
except:
pass
return default_obj
|
'json_string is basicly string that you give to json.loads method'
| def decode(self, json_string):
| default_obj = super(LayerAttributesMangler, self).decode(json_string)
for obj in default_obj:
obj['pk'] = (obj['pk'] + self.basepk)
obj['fields']['layer'] = (obj['fields']['layer'] + self.basepk)
return default_obj
|
'json_string is basicly string that you give to json.loads method'
| def decode(self, json_string):
| default_obj = super(MapMangler, self).decode(json_string)
for obj in default_obj:
obj['pk'] = (obj['pk'] + self.basepk)
from geonode.base.models import ResourceBase
resource = ResourceBase.objects.get(pk=obj['pk'])
obj['fields']['urlsuffix'] = ''
obj['fields']['title_en'] = resource.title
obj['fields']['featuredurl'] = ''
obj['fields']['data_quality_statement_en'] = None
obj['fields']['supplemental_information_en'] = 'No information provided'
obj['fields']['abstract_en'] = ''
obj['fields']['purpose_en'] = None
obj['fields']['constraints_other_en'] = None
try:
obj['fields'].pop('popular_count', None)
except:
pass
try:
obj['fields'].pop('share_count', None)
except:
pass
try:
obj['fields'].pop('title', None)
except:
pass
return default_obj
|
'json_string is basicly string that you give to json.loads method'
| def decode(self, json_string):
| default_obj = super(MapLayersMangler, self).decode(json_string)
for obj in default_obj:
obj['pk'] = (obj['pk'] + self.basepk)
obj['fields']['map'] = (obj['fields']['map'] + self.basepk)
return default_obj
|
'Restore GeoServer Catalog'
| def restore_geoserver_backup(self, settings, target_folder):
| url = settings.OGC_SERVER['default']['PUBLIC_LOCATION']
user = settings.OGC_SERVER['default']['USER']
passwd = settings.OGC_SERVER['default']['PASSWORD']
geoserver_bk_file = os.path.join(target_folder, 'geoserver_catalog.zip')
if (not os.path.exists(geoserver_bk_file)):
print ('Skipping geoserver restore: ' + 'file "{}" not found.'.format(geoserver_bk_file))
return
print (((("Restoring 'GeoServer Catalog [" + url) + "]' into '") + geoserver_bk_file) + "'.")
data = {'restore': {'archiveFile': geoserver_bk_file, 'options': {}}}
headers = {'Content-type': 'application/json'}
r = requests.post((url + 'rest/br/restore/'), data=json.dumps(data), headers=headers, auth=HTTPBasicAuth(user, passwd))
error_backup = ('Could not successfully restore GeoServer ' + 'catalog [{}rest/br/backup/]: {} - {}')
if (r.status_code > 201):
try:
gs_backup = r.json()
except ValueError:
raise ValueError(error_backup.format(url, r.status_code, r.text))
gs_bk_exec_id = gs_backup['restore']['execution']['id']
r = requests.get((((url + 'rest/br/restore/') + str(gs_bk_exec_id)) + '.json'), auth=HTTPBasicAuth(user, passwd))
if (r.status_code == 200):
try:
gs_backup = r.json()
except ValueError:
raise ValueError(error_backup.format(url, r.status_code, r.text))
gs_bk_progress = gs_backup['restore']['execution']['progress']
print gs_bk_progress
raise ValueError(error_backup.format(url, r.status_code, r.text))
else:
try:
gs_backup = r.json()
except ValueError:
raise ValueError(error_backup.format(url, r.status_code, r.text))
gs_bk_exec_id = gs_backup['restore']['execution']['id']
r = requests.get((((url + 'rest/br/restore/') + str(gs_bk_exec_id)) + '.json'), auth=HTTPBasicAuth(user, passwd))
if (r.status_code == 200):
gs_bk_exec_status = gs_backup['restore']['execution']['status']
gs_bk_exec_progress = gs_backup['restore']['execution']['progress']
gs_bk_exec_progress_updated = '0/0'
while ((gs_bk_exec_status != 'COMPLETED') and (gs_bk_exec_status != 'FAILED')):
if (gs_bk_exec_progress != gs_bk_exec_progress_updated):
gs_bk_exec_progress_updated = gs_bk_exec_progress
r = requests.get((((url + 'rest/br/restore/') + str(gs_bk_exec_id)) + '.json'), auth=HTTPBasicAuth(user, passwd))
if (r.status_code == 200):
try:
gs_backup = r.json()
except ValueError:
raise ValueError(error_backup.format(url, r.status_code, r.text))
gs_bk_exec_status = gs_backup['restore']['execution']['status']
gs_bk_exec_progress = gs_backup['restore']['execution']['progress']
print ((str(gs_bk_exec_status) + ' - ') + gs_bk_exec_progress)
time.sleep(3)
else:
raise ValueError(error_backup.format(url, r.status_code, r.text))
else:
raise ValueError(error_backup.format(url, r.status_code, r.text))
|
'Restore Vectorial Data from DB'
| def restore_geoserver_vector_data(self, config, settings, target_folder):
| if config.gs_dump_vector_data:
gs_data_folder = os.path.join(target_folder, 'gs_data_dir', 'data', 'geonode')
if (not os.path.exists(gs_data_folder)):
print ('Skipping geoserver vector data restore: ' + 'directory "{}" not found.'.format(gs_data_folder))
return
datastore = settings.OGC_SERVER['default']['DATASTORE']
if datastore:
ogc_db_name = settings.DATABASES[datastore]['NAME']
ogc_db_user = settings.DATABASES[datastore]['USER']
ogc_db_passwd = settings.DATABASES[datastore]['PASSWORD']
ogc_db_host = settings.DATABASES[datastore]['HOST']
ogc_db_port = settings.DATABASES[datastore]['PORT']
helpers.restore_db(config, ogc_db_name, ogc_db_user, ogc_db_port, ogc_db_host, ogc_db_passwd, gs_data_folder)
|
'Restore external references from XML files'
| def restore_geoserver_externals(self, config, settings, target_folder):
| external_folder = os.path.join(target_folder, helpers.EXTERNAL_ROOT)
dir_util.copy_tree(external_folder, '/')
|
'Make sure there is only one poc and author per resource'
| def clean(self):
| if ((self.role == self.resource.poc_role) or (self.role == self.resource.metadata_author_role)):
contacts = self.resource.contacts.filter(contactrole__role=self.role)
if (contacts.count() == 1):
if (self.contact != contacts.get()):
raise ValidationError(('There can be only one %s for a given resource' % self.role))
if (self.contact.user is None):
bounds = ContactRole.objects.filter(contact=self.contact).count()
if (bounds > 1):
raise ValidationError(('There can be one and only one resource linked to an unbound contact' % self.role))
elif (bounds == 1):
if (ContactRole.objects.filter(contact=self.contact).get().id != self.id):
raise ValidationError(('There can be one and only one resource linked to an unbound contact' % self.role))
|
'Dumps a tree branch to a python data structure.'
| @classmethod
def dump_bulk_tree(cls, parent=None, keep_ids=True):
| qset = cls._get_serializable_model().get_tree(parent)
(ret, lnk) = ([], {})
for pyobj in qset:
serobj = serializers.serialize('python', [pyobj])[0]
fields = serobj['fields']
depth = fields['depth']
fields['text'] = fields['name']
fields['href'] = fields['slug']
del fields['name']
del fields['slug']
del fields['path']
del fields['numchild']
del fields['depth']
if ('id' in fields):
del fields['id']
newobj = {}
for field in fields:
newobj[field] = fields[field]
if keep_ids:
newobj['id'] = serobj['pk']
if (((not parent) and (depth == 1)) or (parent and (depth == parent.depth))):
ret.append(newobj)
else:
parentobj = pyobj.get_parent()
parentser = lnk[parentobj.pk]
if ('nodes' not in parentser):
parentser['nodes'] = []
parentser['nodes'].append(newobj)
lnk[pyobj.pk] = newobj
return ret
|
'Set the four bounds in lat lon projection'
| def set_latlon_bounds(self, box):
| self.bbox_x0 = box[0]
self.bbox_x1 = box[1]
self.bbox_y0 = box[2]
self.bbox_y1 = box[3]
|
'Calculate zoom level and center coordinates in mercator.'
| def set_bounds_from_center_and_zoom(self, center_x, center_y, zoom):
| self.center_x = center_x
self.center_y = center_y
self.zoom = zoom
deg_len_equator = (40075160 / 360)
def get_lon_lat():
wgs84 = Proj(init='epsg:4326')
mercator = Proj(init='epsg:3857')
(lon, lat) = transform(mercator, wgs84, center_x, center_y)
return (lon, lat)
def deg_len():
(lon, lat) = get_lon_lat()
return (math.cos(lat) * deg_len_equator)
(lon, lat) = get_lon_lat()
distance_per_pixel = ((40075160 * math.cos(lat)) / (2 ** (zoom + 8)))
distance_x_degrees = ((distance_per_pixel * 500) / deg_len())
distance_y_degrees = ((distance_per_pixel * 350) / deg_len_equator)
self.bbox_x0 = (lon - distance_x_degrees)
self.bbox_x1 = (lon + distance_x_degrees)
self.bbox_y0 = (lat - distance_y_degrees)
self.bbox_y1 = (lat + distance_y_degrees)
|
'Calculate zoom level and center coordinates in mercator.'
| def set_bounds_from_bbox(self, bbox):
| self.set_latlon_bounds(bbox)
(minx, maxx, miny, maxy) = [float(c) for c in bbox]
x = ((minx + maxx) / 2)
y = ((miny + maxy) / 2)
(center_x, center_y) = forward_mercator((x, y))
xdiff = (maxx - minx)
ydiff = (maxy - miny)
zoom = 0
if ((xdiff > 0) and (ydiff > 0)):
width_zoom = math.log((360 / xdiff), 2)
height_zoom = math.log((360 / ydiff), 2)
zoom = math.ceil(min(width_zoom, height_zoom))
self.zoom = zoom
self.center_x = center_x
self.center_y = center_y
|
'assemble download links for pycsw'
| def download_links(self):
| links = []
for url in self.link_set.all():
if (url.link_type == 'metadata'):
continue
if (url.link_type == 'html'):
links.append((self.title, 'Web address (URL)', 'WWW:LINK-1.0-http--link', url.url))
elif (url.link_type in ('OGC:WMS', 'OGC:WFS', 'OGC:WCS')):
links.append((self.title, url.name, url.link_type, url.url))
else:
description = ('%s (%s Format)' % (self.title, url.name))
links.append((self.title, description, 'WWW:DOWNLOAD-1.0-http--download', url.url))
return links
|
'Return URL for Z/Y/X mapping clients or None if it does not exist.'
| def get_tiles_url(self):
| try:
tiles_link = self.link_set.get(name='Tiles')
except Link.DoesNotExist:
return None
else:
return tiles_link.url
|
'Return Link for legend or None if it does not exist.'
| def get_legend(self):
| try:
legends_link = self.link_set.get(name='Legend')
except Link.DoesNotExist:
return None
except Link.MultipleObjectsReturned:
return None
else:
return legends_link
|
'Return URL for legend or None if it does not exist.
The legend can be either an image (for Geoserver\'s WMS)
or a JSON object for ArcGIS.'
| def get_legend_url(self):
| legend = self.get_legend()
if (legend is None):
return None
return legend.url
|
'Return URL for OGC WMS server None if it does not exist.'
| def get_ows_url(self):
| try:
ows_link = self.link_set.get(name='OGC:WMS')
except Link.DoesNotExist:
return None
else:
return ows_link.url
|
'Return a thumbnail url.
It could be a local one if it exists, a remote one (WMS GetImage) for example
or a \'Missing Thumbnail\' one.'
| def get_thumbnail_url(self):
| local_thumbnails = self.link_set.filter(name='Thumbnail')
if (local_thumbnails.count() > 0):
return local_thumbnails[0].url
remote_thumbnails = self.link_set.filter(name='Remote Thumbnail')
if (remote_thumbnails.count() > 0):
return remote_thumbnails[0].url
return staticfiles.static(settings.MISSING_THUMBNAIL)
|
'Determine if the thumbnail object exists and an image exists'
| def has_thumbnail(self):
| return self.link_set.filter(name='Thumbnail').exists()
|
'Set default permissions and point of contacts.
It is mandatory to call it from descendant classes
but hard to enforce technically via signals or save overriding.'
| def set_missing_info(self):
| from guardian.models import UserObjectPermission
logger.debug('Checking for permissions.')
no_custom_permissions = UserObjectPermission.objects.filter(content_type=ContentType.objects.get_for_model(self.get_self_resource()), object_pk=str(self.pk)).exists()
if (not no_custom_permissions):
logger.debug('There are no permissions for this object, setting default perms.')
self.set_default_permissions()
user = None
if self.owner:
user = self.owner
else:
try:
user = ResourceBase.objects.admin_contact().user
except:
pass
if user:
if (self.poc is None):
self.poc = user
if (self.metadata_author is None):
self.metadata_author = user
|
'Validates that the input is a list or tuple.'
| def validate(self, value):
| if (self.required and (not value)):
raise forms.ValidationError(self.error_messages['required'], code='required')
|
'A handy shortcut for the center_x and center_y properties as a tuple
(read only)'
| @property
def center(self):
| return (self.center_x, self.center_y)
|
'Get a JSON representation of this map suitable for sending to geoserver
for creating a download of all layers'
| def json(self, layer_filter):
| map_layers = MapLayer.objects.filter(map=self.id)
layers = []
for map_layer in map_layers:
if map_layer.local:
layer = Layer.objects.get(alternate=map_layer.name)
layers.append(layer)
else:
pass
if layer_filter:
layers = [l for l in layers if layer_filter(l)]
readme = ((('Title: %s\n' + 'Author: %s\n') + 'Abstract: %s\n') % (self.title, self.poc, self.abstract))
if self.license:
readme += ('License: %s' % self.license)
if self.license.url:
readme += (' (%s)' % self.license.url)
readme += '\n'
if self.constraints_other:
readme += ('Additional constraints: %s\n' % self.constraints_other)
def layer_json(lyr):
return {'name': lyr.alternate, 'service': lyr.service_type, 'serviceURL': '', 'metadataURL': ''}
map_config = {'map': {'readme': readme, 'title': self.title}, 'layers': [layer_json(lyr) for lyr in layers]}
return json.dumps(map_config)
|
'Update this Map\'s details by parsing a JSON object as produced by
a GXP Viewer.
This method automatically persists to the database!'
| def update_from_viewer(self, conf):
| if isinstance(conf, basestring):
conf = json.loads(conf)
self.title = conf['about']['title']
self.abstract = conf['about']['abstract']
self.set_bounds_from_center_and_zoom(conf['map']['center'][0], conf['map']['center'][1], conf['map']['zoom'])
self.projection = conf['map']['projection']
if ((self.uuid is None) or (self.uuid == '')):
self.uuid = str(uuid.uuid1())
def source_for(layer):
return conf['sources'][layer['source']]
layers = [l for l in conf['map']['layers']]
layer_names = set([l.alternate for l in self.local_layers])
for layer in self.layer_set.all():
layer.delete()
self.keywords.add(*conf['map'].get('keywords', []))
for (ordering, layer) in enumerate(layers):
self.layer_set.add(layer_from_viewer_config(MapLayer, layer, source_for(layer), ordering))
self.save()
if (layer_names != set([l.alternate for l in self.local_layers])):
map_changed_signal.send_robust(sender=self, what_changed='layers')
|
'Calculate the bbox from a given list of Layer objects'
| def get_bbox_from_layers(self, layers):
| bbox = None
for layer in layers:
layer_bbox = layer.bbox
if (bbox is None):
bbox = list(layer_bbox[0:4])
else:
bbox[0] = min(bbox[0], layer_bbox[0])
bbox[1] = max(bbox[1], layer_bbox[1])
bbox[2] = min(bbox[2], layer_bbox[2])
bbox[3] = max(bbox[3], layer_bbox[3])
return bbox
|
'Returns True if anonymous (public) user can view map.'
| @property
def is_public(self):
| from guardian.shortcuts import get_anonymous_user
user = get_anonymous_user()
return user.has_perm('base.view_resourcebase', obj=self.resourcebase_ptr)
|
'Returns layer group name from local OWS for this map instance.'
| @property
def layer_group(self):
| if ('geonode.geoserver' in settings.INSTALLED_APPS):
from geonode.geoserver.helpers import gs_catalog, ogc_server_settings
lg_name = ('%s_%d' % (slugify(self.title), self.id))
return {'catalog': gs_catalog.get_layergroup(lg_name), 'ows': ogc_server_settings.ows}
else:
return None
|
'Publishes local map layers as WMS layer group on local OWS.'
| def publish_layer_group(self):
| if ('geonode.geoserver' in settings.INSTALLED_APPS):
from geonode.geoserver.helpers import gs_catalog
from geoserver.layergroup import UnsavedLayerGroup as GsUnsavedLayerGroup
else:
raise Exception('Cannot publish layer group if geonode.geoserver is not in INSTALLED_APPS')
if (not self.is_public):
return 'Only public maps can be saved as layer group.'
map_layers = MapLayer.objects.filter(map=self.id)
layers = []
lg_styles = []
for ml in map_layers:
if ml.local:
layer = Layer.objects.get(alternate=ml.name)
style = (ml.styles or getattr(layer.default_style, 'name', ''))
layers.append(layer)
lg_styles.append(style)
lg_layers = [l.name for l in layers]
lg_bounds = [str(coord) for coord in self.bbox]
lg_name = ('%s_%d' % (slugify(self.title), self.id))
lg = self.layer_group
if (lg is None):
lg = GsUnsavedLayerGroup(gs_catalog, lg_name, lg_layers, lg_styles, lg_bounds)
else:
(lg.layers, lg.styles, lg.bounds) = (lg_layers, lg_styles, lg_bounds)
gs_catalog.save(lg)
return lg_name
|
'POST /maps/new/data -> Test saving a new map'
| def test_map_save(self):
| new_map = reverse('new_map_json')
response = self.client.post(new_map, data=self.viewer_config, content_type='text/json')
self.assertEqual(response.status_code, 401)
self.client.login(username=self.user, password=self.passwd)
response = self.client.post(new_map, data=self.viewer_config, content_type='text/json')
self.assertEquals(response.status_code, 200)
map_id = int(json.loads(response.content)['id'])
self.client.logout()
self.assertEquals(map_id, 18)
map_obj = Map.objects.get(id=map_id)
self.assertEquals(map_obj.title, 'Title')
self.assertEquals(map_obj.abstract, 'Abstract')
self.assertEquals(map_obj.layer_set.all().count(), 1)
self.assertEquals(map_obj.keyword_list(), [u'keywords', u'saving'])
self.assertNotEquals(map_obj.bbox_x0, None)
self.client.login(username=self.user, password=self.passwd)
response = self.client.post(new_map, data='not a valid viewer config', content_type='text/json')
self.assertEquals(response.status_code, 400)
self.client.logout()
|
'/maps/[id]/data -> Test fetching a map in JSON'
| def test_map_fetch(self):
| map_obj = Map.objects.get(id=1)
map_obj.set_default_permissions()
response = self.client.get(reverse('map_json', args=(map_obj.id,)))
self.assertEquals(response.status_code, 200)
cfg = json.loads(response.content)
self.assertEquals(cfg['about']['abstract'], 'GeoNode default map abstract')
self.assertEquals(cfg['about']['title'], 'GeoNode Default Map')
self.assertEquals(len(cfg['map']['layers']), 5)
|
'Make some assertions about the data structure produced for serialization
to a JSON map configuration'
| def test_map_to_json(self):
| map_obj = Map.objects.get(id=1)
cfg = map_obj.viewer_json(None, None)
self.assertEquals(cfg['about']['abstract'], 'GeoNode default map abstract')
self.assertEquals(cfg['about']['title'], 'GeoNode Default Map')
def is_wms_layer(x):
if ('source' in x):
return (cfg['sources'][x['source']]['ptype'] == 'gxp_wmscsource')
return False
layernames = [x['name'] for x in cfg['map']['layers'] if is_wms_layer(x)]
self.assertEquals(layernames, ['geonode:CA'])
|
'/maps/1/wmc -> Test map WMC export
Make some assertions about the data structure produced
for serialization to a Web Map Context Document'
| def test_map_to_wmc(self):
| map_obj = Map.objects.get(id=1)
map_obj.set_default_permissions()
response = self.client.get(reverse('map_wmc', args=(map_obj.id,)))
self.assertEquals(response.status_code, 200)
wmc = etree.fromstring(response.content)
namespace = '{http://www.opengis.net/context}'
title = '{ns}General/{ns}Title'.format(ns=namespace)
abstract = '{ns}General/{ns}Abstract'.format(ns=namespace)
self.assertEquals(wmc.attrib.get('id'), '1')
self.assertEquals(wmc.find(title).text, 'GeoNode Default Map')
self.assertEquals(wmc.find(abstract).text, 'GeoNode default map abstract')
|
'Make some assertions about the data structure produced for serialization
to a new JSON map configuration'
| def test_newmap_to_json(self):
| response = self.client.get(reverse('new_map_json'))
cfg = json.loads(response.content)
self.assertEquals(cfg['defaultSourceType'], 'gxp_wmscsource')
|
'/maps/1 -> Test accessing the map browse view function'
| def test_map_details(self):
| map_obj = Map.objects.get(id=1)
map_obj.set_default_permissions()
response = self.client.get(reverse('map_detail', args=(map_obj.id,)))
self.assertEquals(response.status_code, 200)
|
'Verify that the ajax_layer_permissions view is behaving as expected'
| def test_ajax_map_permissions(self):
| mapid = Map.objects.all()[0].pk
invalid_mapid = '42'
def url(id):
return reverse('resource_permissions', args=[id])
response = self.client.post(url(invalid_mapid), data=json.dumps(self.perm_spec), content_type='application/json')
self.assertEquals(response.status_code, 404)
response = self.client.get(url(mapid))
assert ('permissions' in response.content)
response = self.client.post(url(mapid), data=json.dumps(self.perm_spec), content_type='application/json')
self.assertEquals(response.status_code, 401)
logged_in = self.client.login(username='bobby', password='bob')
self.assertEquals(logged_in, True)
response = self.client.post(url(mapid), data=json.dumps(self.perm_spec), content_type='application/json')
self.assertEquals(response.status_code, 401)
logged_in = self.client.login(username='admin', password='admin')
self.assertEquals(logged_in, True)
response = self.client.post(url(mapid), data=json.dumps(self.perm_spec), content_type='application/json')
self.assertEquals(response.status_code, 200)
|
'Test that map metadata can be properly rendered'
| def test_map_metadata(self):
| self.client.login(username=self.user, password=self.passwd)
new_map = reverse('new_map_json')
response = self.client.post(new_map, data=self.viewer_config, content_type='text/json')
self.assertEquals(response.status_code, 200)
map_id = int(json.loads(response.content)['id'])
self.client.logout()
url = reverse('map_metadata', args=(map_id,))
response = self.client.post(url)
self.assertEquals(response.status_code, 302)
self.client.login(username='norman', password='norman')
response = self.client.post(url)
self.assertEquals(response.status_code, 302)
self.client.logout()
self.client.login(username=self.user, password=self.passwd)
response = self.client.get(url)
self.assertEquals(response.status_code, 200)
self.client.login(username=self.user, password=self.passwd)
response = self.client.post(url)
self.assertEquals(response.status_code, 200)
|
'Test that map can be properly removed'
| def test_map_remove(self):
| self.client.login(username=self.user, password=self.passwd)
new_map = reverse('new_map_json')
response = self.client.post(new_map, data=self.viewer_config, content_type='text/json')
self.assertEquals(response.status_code, 200)
map_id = int(json.loads(response.content)['id'])
self.client.logout()
url = reverse('map_remove', args=(map_id,))
response = self.client.post(url)
self.assertEquals(response.status_code, 302)
self.client.login(username='norman', password='norman')
response = self.client.post(url)
self.assertEquals(response.status_code, 302)
self.client.logout()
self.client.login(username=self.user, password=self.passwd)
response = self.client.get(url)
self.assertEquals(response.status_code, 200)
response = self.client.post(url)
self.assertEquals(response.status_code, 302)
self.assertEquals(response['Location'], 'http://testserver/maps/')
response = self.client.get(url)
self.assertEquals(response.status_code, 404)
|
'Test that map can be properly embedded'
| def test_map_embed(self):
| self.client.login(username=self.user, password=self.passwd)
new_map = reverse('new_map_json')
response = self.client.post(new_map, data=self.viewer_config, content_type='text/json')
self.assertEquals(response.status_code, 200)
map_id = int(json.loads(response.content)['id'])
self.client.logout()
url = reverse('map_embed', args=(map_id,))
url_no_id = reverse('map_embed')
self.client.login(username=self.user, password=self.passwd)
response = self.client.get(url)
self.assertEquals(response.status_code, 200)
if hasattr(response, 'xframe_options_exempt'):
self.assertTrue(response.xframe_options_exempt)
map_obj = Map.objects.get(id=map_id)
config_map = map_obj.viewer_json(None, None)
response_config_dict = json.loads(response.context['config'])
self.assertEquals(config_map['about']['abstract'], response_config_dict['about']['abstract'])
self.assertEquals(config_map['about']['title'], response_config_dict['about']['title'])
response = self.client.get(url_no_id)
self.assertEquals(response.status_code, 200)
config_default = default_map_config(None)[0]
response_config_dict = json.loads(response.context['config'])
self.assertEquals(config_default['about']['abstract'], response_config_dict['about']['abstract'])
self.assertEquals(config_default['about']['title'], response_config_dict['about']['title'])
|
'Test that map view can be properly rendered'
| def test_map_view(self):
| self.client.login(username=self.user, password=self.passwd)
new_map = reverse('new_map_json')
response = self.client.post(new_map, data=self.viewer_config, content_type='text/json')
self.assertEquals(response.status_code, 200)
map_id = int(json.loads(response.content)['id'])
self.client.logout()
url = reverse('map_view', args=(map_id,))
response = self.client.get(url)
self.assertEquals(response.status_code, 200)
self.client.login(username='norman', password='norman')
response = self.client.get(url)
self.assertEquals(response.status_code, 200)
self.client.logout()
self.client.login(username=self.user, password=self.passwd)
response = self.client.get(url)
self.assertEquals(response.status_code, 200)
map_obj = Map.objects.get(id=map_id)
config_map = map_obj.viewer_json(None, None)
response_config_dict = json.loads(response.context['config'])
self.assertEquals(config_map['about']['abstract'], response_config_dict['about']['abstract'])
self.assertEquals(config_map['about']['title'], response_config_dict['about']['title'])
|
'Test that new map config can be properly assigned'
| def test_new_map_config(self):
| self.client.login(username='admin', password='admin')
m = Map()
admin_user = get_user_model().objects.get(username='admin')
layer_name = Layer.objects.all()[0].alternate
m.create_from_layer_list(admin_user, [layer_name], 'title', 'abstract')
map_id = m.id
url = reverse('new_map_json')
response = self.client.get(url, {'copy': map_id})
self.assertEquals(response.status_code, 200)
map_obj = Map.objects.get(id=map_id)
config_map = map_obj.viewer_json(None, None)
response_config_dict = json.loads(response.content)
self.assertEquals(config_map['map']['layers'], response_config_dict['map']['layers'])
response = self.client.get(url)
self.assertEquals(response.status_code, 200)
config_default = default_map_config(None)[0]
response_config_dict = json.loads(response.content)
self.assertEquals(config_default['about']['abstract'], response_config_dict['about']['abstract'])
self.assertEquals(config_default['about']['title'], response_config_dict['about']['title'])
response = self.client.get(url, {'layer': layer_name})
self.assertEquals(response.status_code, 200)
response_dict = json.loads(response.content)
self.assertEquals(response_dict['fromLayer'], True)
self.client.logout()
response = self.client.post(url, {'layer': layer_name})
self.assertEquals(response.status_code, 401)
self.client.login(username='admin', password='admin')
response = self.client.post(url, {'layer': layer_name})
self.assertEquals(response.status_code, 400)
response = self.client.post(url, data=self.viewer_config, content_type='text/json')
self.assertEquals(response.status_code, 200)
map_id = int(json.loads(response.content)['id'])
response = self.client.put(url)
self.assertEquals(response.status_code, 405)
|
'Test map rating is removed on map remove'
| def test_rating_map_remove(self):
| self.client.login(username=self.user, password=self.passwd)
new_map = reverse('new_map_json')
response = self.client.post(new_map, data=self.viewer_config, content_type='text/json')
map_id = int(json.loads(response.content)['id'])
ctype = ContentType.objects.get(model='map')
OverallRating.objects.create(category=1, object_id=map_id, content_type=ctype, rating=3)
response = self.client.post(reverse('map_remove', args=(map_id,)))
self.assertEquals(response.status_code, 302)
rating = OverallRating.objects.filter(category=1, object_id=map_id)
self.assertEquals(rating.count(), 0)
|
'Test fix_baselayers function, used by the fix_baselayers command'
| def test_fix_baselayers(self):
| map_id = 1
map_obj = Map.objects.get(id=map_id)
n_baselayers = (len(settings.MAP_BASELAYERS) - 1)
n_locallayers = map_obj.layer_set.filter(local=True).count()
fix_baselayers(map_id)
self.assertEquals(map_obj.layer_set.all().count(), (n_baselayers + n_locallayers))
|
'Test if moderation flag works'
| def test_moderated_upload(self):
| with self.settings(ADMIN_MODERATE_UPLOADS=False):
self.client.login(username=self.user, password=self.passwd)
new_map = reverse('new_map_json')
response = self.client.post(new_map, data=VIEWER_CONFIG, content_type='text/json')
self.assertEquals(response.status_code, 200)
map_id = int(json.loads(response.content)['id'])
l = Map.objects.get(id=map_id)
self.assertTrue(l.is_published)
with self.settings(ADMIN_MODERATE_UPLOADS=True):
self.client.login(username=self.user, password=self.passwd)
new_map = reverse('new_map_json')
response = self.client.post(new_map, data=VIEWER_CONFIG, content_type='text/json')
self.assertEquals(response.status_code, 200)
map_id = int(json.loads(response.content)['id'])
l = Map.objects.get(id=map_id)
self.assertFalse(l.is_published)
|
'Returns a list of the Profile\'s keywords.'
| def keyword_list(self):
| return [kw.name for kw in self.keywords.all()]
|
'verify we can create an account and modify it keeping emails in sync'
| def test_account_email_sync(self):
| from geonode.people.models import Profile
email = '[email protected]'
joebob = Profile.objects.create(username='joebob', email=email)
self.assertEqual(joebob.emailaddress_set.get(primary=True).email, email)
email = '[email protected]'
joebob.email = email
joebob.save()
self.assertEqual(joebob.emailaddress_set.get(primary=True).email, email)
email = joebob.emailaddress_set.get(primary=True)
email.email = '[email protected]'
email.save()
joebob = Profile.objects.get(id=joebob.id)
self.assertEqual(email.email, joebob.email)
|
'Use special form during user creation'
| def get_form(self, request, obj=None, **kwargs):
| defaults = {}
if (obj is None):
defaults.update({'form': self.add_form, 'fields': admin.utils.flatten_fieldsets(self.add_fieldsets)})
defaults.update(kwargs)
return super(ProfileAdmin, self).get_form(request, obj, **defaults)
|
'Determines the HttpResponse for the add_view stage. It mostly defers to
its superclass implementation but is customized because the User model
has a slightly different workflow.'
| def response_add(self, request, obj, post_url_continue=None):
| if (('_addanother' not in request.POST) and (IS_POPUP_VAR not in request.POST)):
request.POST['_continue'] = 1
return super(ProfileAdmin, self).response_add(request, obj, post_url_continue)
|
'Tests the creation of a document with no relations'
| def test_create_document_with_no_rel(self):
| f = SimpleUploadedFile('test_img_file.gif', self.imgfile.read(), 'image/gif')
superuser = get_user_model().objects.get(pk=2)
c = Document.objects.create(doc_file=f, owner=superuser, title='theimg')
c.set_default_permissions()
self.assertEquals(Document.objects.get(pk=c.id).title, 'theimg')
|
'Tests the creation of a document with no a map related'
| def test_create_document_with_rel(self):
| f = SimpleUploadedFile('test_img_file.gif', self.imgfile.read(), 'image/gif')
superuser = get_user_model().objects.get(pk=2)
c = Document.objects.create(doc_file=f, owner=superuser, title='theimg')
m = Map.objects.all()[0]
ctype = ContentType.objects.get_for_model(m)
l = DocumentResourceLink.objects.create(document_id=c.id, content_type=ctype, object_id=m.id)
self.assertEquals(Document.objects.get(pk=c.id).title, 'theimg')
self.assertEquals(DocumentResourceLink.objects.get(pk=l.id).object_id, m.id)
|
'Tests creating an external document instead of a file.'
| def test_create_document_url(self):
| superuser = get_user_model().objects.get(pk=2)
c = Document.objects.create(doc_url='http://geonode.org/map.pdf', owner=superuser, title='GeoNode Map')
doc = Document.objects.get(pk=c.id)
self.assertEquals(doc.title, 'GeoNode Map')
self.assertEquals(doc.extension, 'pdf')
|
'Tests creating and updating external documents.'
| def test_create_document_url_view(self):
| self.client.login(username='admin', password='admin')
form_data = {'title': 'GeoNode Map', 'permissions': '{"users":{"AnonymousUser": ["view_resourcebase"]},"groups":{}}', 'doc_url': 'http://www.geonode.org/map.pdf'}
response = self.client.post(reverse('document_upload'), data=form_data)
self.assertEqual(response.status_code, 302)
d = Document.objects.get(title='GeoNode Map')
self.assertEqual(d.doc_url, 'http://www.geonode.org/map.pdf')
form_data['doc_url'] = 'http://www.geonode.org/mapz.pdf'
response = self.client.post(reverse('document_replace', args=[d.id]), data=form_data)
self.assertEqual(response.status_code, 302)
d = Document.objects.get(title='GeoNode Map')
self.assertEqual(d.doc_url, 'http://www.geonode.org/mapz.pdf')
|
'Tests the Upload form.'
| def test_upload_document_form(self):
| form_data = dict()
form = DocumentCreateForm(data=form_data)
self.assertFalse(form.is_valid())
self.assertTrue(('title' in form.errors))
self.assertTrue(('permissions' in form.errors))
self.assertTrue(('__all__' in form.errors))
form_data = {'title': 'GeoNode Map', 'permissions': '{"anonymous":"document_readonly","authenticated":"resourcebase_readwrite","users":[]}', 'doc_url': 'http://www.geonode.org/map.pdf'}
form = DocumentCreateForm(data=form_data)
self.assertTrue(form.is_valid())
self.assertTrue(isinstance(form.cleaned_data['permissions'], dict))
form_data['permissions'] = 'non-json string'
self.assertTrue(('permissions' in DocumentCreateForm(data=form_data).errors))
form_data = {'title': 'GeoNode Map', 'permissions': '{"anonymous":"document_readonly","authenticated":"resourcebase_readwrite","users":[]}'}
file_data = {'doc_file': SimpleUploadedFile('test_img_file.gif', self.imgfile.read(), 'image/gif')}
form = DocumentCreateForm(form_data, file_data)
self.assertTrue(form.is_valid())
form_data['doc_url'] = 'http://www.geonode.org/map.pdf'
form = DocumentCreateForm(form_data, file_data)
self.assertFalse(form.is_valid())
self.assertTrue(('__all__' in form.errors))
|
'/documents/1 -> Test accessing the detail view of a document'
| def test_document_details(self):
| d = Document.objects.get(pk=1)
d.set_default_permissions()
response = self.client.get(reverse('document_detail', args=(str(d.id),)))
self.assertEquals(response.status_code, 200)
|
'Test the form page is returned correctly via GET request /documents/upload'
| def test_access_document_upload_form(self):
| log = self.client.login(username='bobby', password='bob')
self.assertTrue(log)
response = self.client.get(reverse('document_upload'))
self.assertTrue(('Upload Documents' in response.content))
|
'/documents/upload -> Test uploading a document'
| def test_document_isuploaded(self):
| f = SimpleUploadedFile('test_img_file.gif', self.imgfile.read(), 'image/gif')
m = Map.objects.all()[0]
self.client.login(username='admin', password='admin')
response = self.client.post(reverse('document_upload'), data={'file': f, 'title': 'uploaded_document', 'q': m.id, 'type': 'map', 'permissions': '{"users":{"AnonymousUser": ["view_resourcebase"]}}'}, follow=True)
self.assertEquals(response.status_code, 200)
|
'Verify that the set_document_permissions view is behaving as expected'
| def test_set_document_permissions(self):
| document = Document.objects.all()[0]
document.set_permissions(self.perm_spec)
self.assertFalse(self.anonymous_user.has_perm('view_resourcebase', document.get_self_resource()))
current_perms = document.get_all_level_info()
self.assertEqual(len(current_perms['users'].keys()), 2)
for (username, perm) in self.perm_spec['users'].items():
user = get_user_model().objects.get(username=username)
self.assertTrue(user.has_perm(perm, document.get_self_resource()))
|
'Verify that the ajax_document_permissions view is behaving as expected'
| def test_ajax_document_permissions(self):
| f = SimpleUploadedFile('test_img_file.gif', self.imgfile.read(), 'image/gif')
superuser = get_user_model().objects.get(pk=2)
document = Document.objects.create(doc_file=f, owner=superuser, title='theimg')
document.set_default_permissions()
document_id = document.id
invalid_document_id = 20
response = self.client.post(reverse('resource_permissions', args=(invalid_document_id,)), data=json.dumps(self.perm_spec), content_type='application/json')
self.assertEquals(response.status_code, 404)
response = self.client.get(reverse('resource_permissions', args=(document_id,)))
assert ('permissions' in response.content)
response = self.client.post(reverse('resource_permissions', args=(document_id,)), data=json.dumps(self.perm_spec), content_type='application/json')
self.assertEquals(response.status_code, 401)
logged_in = self.client.login(username='bobby', password='bob')
self.assertEquals(logged_in, True)
response = self.client.post(reverse('resource_permissions', args=(document_id,)), data=json.dumps(self.perm_spec), content_type='application/json')
self.assertEquals(response.status_code, 401)
logged_in = self.client.login(username='admin', password='admin')
self.assertEquals(logged_in, True)
response = self.client.post(reverse('resource_permissions', args=(document_id,)), data=json.dumps(self.perm_spec), content_type='application/json')
self.assertEquals(response.status_code, 200)
|
'Test if moderation flag works'
| def test_moderated_upload(self):
| with self.settings(ADMIN_MODERATE_UPLOADS=False):
document_upload_url = reverse('document_upload')
self.client.login(username=self.user, password=self.passwd)
input_path = self._get_input_path()
with open(input_path, 'rb') as f:
data = {'title': 'document title', 'doc_file': f, 'doc_url': '', 'resource': '', 'permissions': '{}'}
resp = self.client.post(document_upload_url, data=data)
self.assertEqual(resp.status_code, 302)
dname = 'document title'
l = Document.objects.get(title=dname)
self.assertTrue(l.is_published)
l.delete()
with self.settings(ADMIN_MODERATE_UPLOADS=True):
document_upload_url = reverse('document_upload')
self.client.login(username=self.user, password=self.passwd)
input_path = self._get_input_path()
with open(input_path, 'rb') as f:
data = {'title': 'document title', 'doc_file': f, 'doc_url': '', 'resource': '', 'permissions': '{}'}
resp = self.client.post(document_upload_url, data=data)
self.assertEqual(resp.status_code, 302)
dname = 'document title'
l = Document.objects.get(title=dname)
self.assertFalse(l.is_published)
|
'Tests the creation of document links.'
| def test_create_document_with_links(self):
| f = SimpleUploadedFile('test_img_file.gif', self.test_file.read(), 'image/gif')
superuser = get_user_model().objects.get(pk=2)
d = Document.objects.create(doc_file=f, owner=superuser, title='theimg')
self.assertEquals(Document.objects.get(pk=d.id).title, 'theimg')
maps = list(Map.objects.all())
layers = list(Layer.objects.all())
resources = (maps + layers)
mixin1 = DocumentFormMixin()
mixin1.instance = d
mixin1.cleaned_data = dict(links=mixin1.generate_link_values(resources=resources))
mixin1.save_many2many()
for resource in resources:
ct = ContentType.objects.get_for_model(resource)
l = DocumentResourceLink.objects.get(document_id=d.id, content_type=ct.id, object_id=resource.id)
self.assertEquals(l.object_id, resource.id)
mixin2 = DocumentFormMixin()
mixin2.instance = d
mixin2.cleaned_data = dict(links=mixin2.generate_link_values(resources=layers))
mixin2.save_many2many()
for resource in layers:
ct = ContentType.objects.get_for_model(resource)
l = DocumentResourceLink.objects.get(document_id=d.id, content_type=ct.id, object_id=resource.id)
self.assertEquals(l.object_id, resource.id)
for resource in maps:
ct = ContentType.objects.get_for_model(resource)
with self.assertRaises(DocumentResourceLink.DoesNotExist):
DocumentResourceLink.objects.get(document_id=d.id, content_type=ct.id, object_id=resource.id)
|
'Ensures the doc_file or the doc_url field is populated.'
| def clean(self):
| cleaned_data = super(DocumentReplaceForm, self).clean()
doc_file = self.cleaned_data.get('doc_file')
doc_url = self.cleaned_data.get('doc_url')
if ((not doc_file) and (not doc_url)):
raise forms.ValidationError(_('Document must be a file or url.'))
if (doc_file and doc_url):
raise forms.ValidationError(_('A document cannot have both a file and a url.'))
return cleaned_data
|
'Ensures the doc_file is valid.'
| def clean_doc_file(self):
| doc_file = self.cleaned_data.get('doc_file')
if (doc_file and (not (os.path.splitext(doc_file.name)[1].lower()[1:] in settings.ALLOWED_DOCUMENT_TYPES))):
raise forms.ValidationError(_('This file type is not allowed'))
return doc_file
|
'Ensures the JSON field is JSON.'
| def clean_permissions(self):
| permissions = self.cleaned_data['permissions']
try:
return json.loads(permissions)
except ValueError:
raise forms.ValidationError(_('Permissions must be valid JSON.'))
|
'Ensures the doc_file or the doc_url field is populated.'
| def clean(self):
| cleaned_data = super(DocumentCreateForm, self).clean()
doc_file = self.cleaned_data.get('doc_file')
doc_url = self.cleaned_data.get('doc_url')
if ((not doc_file) and (not doc_url)):
raise forms.ValidationError(_('Document must be a file or url.'))
if (doc_file and doc_url):
raise forms.ValidationError(_('A document cannot have both a file and a url.'))
return cleaned_data
|
'Ensures the doc_file is valid.'
| def clean_doc_file(self):
| doc_file = self.cleaned_data.get('doc_file')
if (doc_file and (not (os.path.splitext(doc_file.name)[1].lower()[1:] in settings.ALLOWED_DOCUMENT_TYPES))):
raise forms.ValidationError(_('This file type is not allowed'))
return doc_file
|
'If the form is valid, save the associated model.'
| def form_valid(self, form):
| self.object = form.save(commit=False)
self.object.owner = self.request.user
is_published = (not (settings.RESOURCE_PUBLISHING or settings.ADMIN_MODERATE_UPLOADS))
self.object.is_published = is_published
self.object.save()
form.save_many2many()
self.object.set_permissions(form.cleaned_data['permissions'])
abstract = None
date = None
regions = []
keywords = []
bbox = None
if getattr(settings, 'EXIF_ENABLED', False):
try:
from geonode.contrib.exif.utils import exif_extract_metadata_doc
exif_metadata = exif_extract_metadata_doc(self.object)
if exif_metadata:
date = exif_metadata.get('date', None)
keywords.extend(exif_metadata.get('keywords', []))
bbox = exif_metadata.get('bbox', None)
abstract = exif_metadata.get('abstract', None)
except:
print 'Exif extraction failed.'
if getattr(settings, 'NLP_ENABLED', False):
try:
from geonode.contrib.nlp.utils import nlp_extract_metadata_doc
nlp_metadata = nlp_extract_metadata_doc(self.object)
if nlp_metadata:
regions.extend(nlp_metadata.get('regions', []))
keywords.extend(nlp_metadata.get('keywords', []))
except:
print 'NLP extraction failed.'
if abstract:
self.object.abstract = abstract
self.object.save()
if date:
self.object.date = date
self.object.date_type = 'Creation'
self.object.save()
if (len(regions) > 0):
self.object.regions.add(*regions)
if (len(keywords) > 0):
self.object.keywords.add(*keywords)
if bbox:
(bbox_x0, bbox_x1, bbox_y0, bbox_y1) = bbox
Document.objects.filter(id=self.object.pk).update(bbox_x0=bbox_x0, bbox_x1=bbox_x1, bbox_y0=bbox_y0, bbox_y1=bbox_y1)
if getattr(settings, 'SLACK_ENABLED', False):
try:
from geonode.contrib.slack.utils import build_slack_message_document, send_slack_message
send_slack_message(build_slack_message_document('document_new', self.object))
except:
print 'Could not send slack message for new document.'
return HttpResponseRedirect(reverse('document_metadata', args=(self.object.id,)))
|
'If the form is valid, save the associated model.'
| def form_valid(self, form):
| self.object = form.save()
return HttpResponseRedirect(reverse('document_metadata', args=(self.object.id,)))
|
'Tests the activity functionality when a layer is saved.'
| def test_layer_activity(self):
| self.assertEqual(Action.objects.all().count(), Layer.objects.all().count())
action = Action.objects.all()[0]
layer = action.action_object
self.assertEqual(action.actor, action.action_object.owner)
self.assertEqual(action.data.get('raw_action'), 'created')
self.assertEqual(action.data.get('object_name'), layer.name)
self.assertTrue(isinstance(action.action_object, Layer))
self.assertIsNone(action.target)
template_tag = activity_item(Action.objects.all()[0])
self.assertEqual(template_tag.get('username'), action.actor.username)
self.assertEqual(template_tag.get('object_name'), layer.name)
self.assertEqual(template_tag.get('actor'), action.actor)
self.assertEqual(template_tag.get('verb'), _('uploaded'))
self.assertEqual(template_tag.get('action'), action)
self.assertEqual(template_tag.get('activity_class'), 'upload')
layer_name = layer.name
layer.delete()
action = Action.objects.all()[0]
self.assertEqual(action.data.get('raw_action'), 'deleted')
self.assertEqual(action.data.get('object_name'), layer_name)
self.assertIsNone(action.action_object)
self.assertIsNone(action.target)
action = Action.objects.all()[0]
template_tag = activity_item(action)
self.assertEqual(template_tag.get('activity_class'), 'delete')
self.assertEqual(template_tag.get('object_name'), layer_name)
self.assertEqual(template_tag.get('verb'), _('deleted'))
content_type = ContentType.objects.get_for_model(Layer)
layer = Layer.objects.all()[0]
comment = Comment(author=self.user, content_type=content_type, object_id=layer.id, comment='This is a cool layer.')
comment.save()
action = Action.objects.all()[0]
self.assertEqual(action.actor, self.user)
self.assertEqual(action.data.get('raw_action'), 'created')
self.assertEqual(action.action_object, comment)
self.assertEqual(action.target, layer)
template_tag = activity_item(action)
self.assertEqual(template_tag.get('verb'), _('added a comment'))
self.assertEqual(template_tag.get('activity_class'), 'comment')
self.assertEqual(template_tag.get('target'), action.target)
self.assertEqual(template_tag.get('preposition'), _('on'))
self.assertIsNone(template_tag.get('object'))
self.assertEqual(template_tag.get('target'), layer)
self.assertIn(action, actor_stream(self.user))
|
'Test registering an indexed WMS'
| def test_register_indexed_wms(self):
| self.client.login(username='admin', password='admin')
response = self.client.post(reverse('register_service'), {'type': 'WMS', 'url': 'http://metaspatial.net/cgi-bin/ogc-wms.xml'})
self.assertEqual(response.status_code, 200)
service_dict = json.loads(response.content)[0]
try:
service = Service.objects.get(id=service_dict['service_id'])
self.assertTrue((ServiceLayer.objects.filter(service=service).count() > 0))
self.assertEqual(service.method, 'I')
self.assertEqual(service.type, 'WMS')
self.assertEqual(service.ptype, 'gxp_wmscsource')
except Exception as e:
traceback.print_exc(file=sys.stdout)
self.fail(('Service not created: %s' % str(e)))
|
'Test registering an arcrest service'
| def test_register_arcrest(self):
| self.client.login(username='admin', password='admin')
response = self.client.post(reverse('register_service'), {'type': 'REST', 'url': 'http://maps1.arcgisonline.com/ArcGIS/rest/services/EPA_Facilities/MapServer'})
self.assertEqual(response.status_code, 200)
service_dict = json.loads(response.content)[0]
try:
service = Service.objects.get(id=service_dict['service_id'])
self.assertTrue((ServiceLayer.objects.filter(service=service).count() > 0))
self.assertEqual(service.method, 'I')
self.assertEqual(service.type, 'REST')
self.assertEqual(service.ptype, 'gxp_arcrestsource')
except Exception as e:
self.fail(('Service not created: %s' % str(e)))
|
'Returns the groups that user is a member of. If the user is a superuser, all groups are returned.'
| @classmethod
def groups_for_user(cls, user):
| if user.is_authenticated():
if user.is_superuser:
return cls.objects.all()
return cls.objects.filter(groupmember__user=user)
return []
|
'Returns a list of the Group\'s keywords.'
| def keyword_list(self):
| return [kw.name for kw in self.keywords.all()]
|
'Returns a generator of objects that this group has permissions on.
:param resource_type: Filter\'s the queryset to objects with the same type.'
| def resources(self, resource_type=None):
| queryset = get_objects_for_group(self.group, ['base.view_resourcebase', 'base.change_resourcebase'], any_perm=True)
if resource_type:
queryset = [item for item in queryset if hasattr(item, resource_type)]
for resource in queryset:
(yield resource)
|
'Returns a queryset of the group\'s managers.'
| def get_managers(self):
| return get_user_model().objects.filter(id__in=self.member_queryset().filter(role='manager').values_list('user', flat=True))
|
'Ensures that when a user is in a group, the group permissions
extend to the user.'
| def test_group_permissions_extend_to_user(self):
| layer = Layer.objects.all()[0]
layer.set_default_permissions()
self.assertTrue(self.anonymous_user.has_perm('view_resourcebase', layer.get_self_resource()))
self.assertTrue(self.norman.has_perm('view_resourcebase', layer.get_self_resource()))
self.assertFalse(self.norman.has_perm('change_resourcebase', layer.get_self_resource()))
self.assertFalse(self.bar.user_is_member(self.norman))
self.bar.join(self.norman)
self.assertTrue(self.bar.user_is_member(self.norman))
permissions = {'groups': {'bar': ['view_resourcebase', 'change_resourcebase']}}
layer.set_permissions(permissions)
self.assertTrue(self.norman.has_perm('view_resourcebase', layer.get_self_resource()))
self.assertTrue(self.norman.has_perm('change_resourcebase', layer.get_self_resource()))
self.assertFalse(self.bar.user_is_member(self.test_user))
self.assertFalse(self.test_user.has_perm('change_resourcebase', layer.get_self_resource()))
self.bar.join(self.test_user)
self.assertTrue(self.test_user.has_perm('change_resourcebase', layer.get_self_resource()))
|
'Tests the resources method on a Group object.'
| def test_group_resource(self):
| layer = Layer.objects.all()[0]
map = Map.objects.all()[0]
perm_spec = {'groups': {'bar': ['change_resourcebase']}}
layer.set_permissions(perm_spec)
map.set_permissions(perm_spec)
self.assertTrue((layer.get_self_resource() in self.bar.resources()))
self.assertTrue((map.get_self_resource() in self.bar.resources()))
self.assertTrue((layer.get_self_resource() in self.bar.resources(resource_type='layer')))
self.assertTrue((map.get_self_resource() not in self.bar.resources(resource_type='layer')))
layer.set_permissions('{}')
self.assertFalse((layer.get_self_resource() in self.bar.resources()))
|
'Tests the perms_info function (which passes permissions to the response context).'
| def test_perms_info(self):
| layer = Layer.objects.all()[0]
layer.set_default_permissions()
perms_info = layer.get_all_level_info()
self.assertEqual(len(perms_info['groups'].keys()), 1)
layer.set_permissions({'groups': {'bar': ['view_resourcebase']}})
perms_info = _perms_info_json(layer)
self.assertDictEqual(json.loads(perms_info)['groups'], {'bar': ['view_resourcebase']})
|
'Tests that the client can get and set group permissions through the test_resource_permissions view.'
| def test_resource_permissions(self):
| self.assertTrue(self.client.login(username='admin', password='admin'))
layer = Layer.objects.all()[0]
document = Document.objects.all()[0]
map_obj = Map.objects.all()[0]
layer.set_default_permissions()
document.set_default_permissions()
map_obj.set_default_permissions()
objects = (layer, document, map_obj)
for obj in objects:
response = self.client.get(reverse('resource_permissions', kwargs=dict(resource_id=obj.id)))
self.assertEqual(response.status_code, 200)
js = json.loads(response.content)
permissions = js.get('permissions', dict())
if (isinstance(permissions, unicode) or isinstance(permissions, str)):
permissions = json.loads(permissions)
expected_permissions = {}
if settings.DEFAULT_ANONYMOUS_DOWNLOAD_PERMISSION:
expected_permissions.setdefault(u'anonymous', []).append(u'download_resourcebase')
if settings.DEFAULT_ANONYMOUS_VIEW_PERMISSION:
expected_permissions.setdefault(u'anonymous', []).append(u'view_resourcebase')
self.assertDictEqual(permissions.get('groups'), expected_permissions)
permissions = {'groups': {'bar': ['change_resourcebase']}, 'users': {'admin': ['change_resourcebase']}}
response = self.client.post(reverse('resource_permissions', kwargs=dict(resource_id=obj.id)), data=json.dumps(permissions), content_type='application/json')
self.assertEqual(response.status_code, 200)
response = self.client.get(reverse('resource_permissions', kwargs=dict(resource_id=obj.id)))
js = json.loads(response.content)
permissions = js.get('permissions', dict())
if (isinstance(permissions, unicode) or isinstance(permissions, str)):
permissions = json.loads(permissions)
self.assertDictEqual(permissions['groups'], {'bar': ['change_resourcebase']})
permissions = {'users': {'admin': ['change_resourcebase']}}
response = self.client.post(reverse('resource_permissions', kwargs=dict(resource_id=obj.id)), data=json.dumps(permissions), content_type='application/json')
self.assertEqual(response.status_code, 200)
response = self.client.get(reverse('resource_permissions', kwargs=dict(resource_id=obj.id)))
js = json.loads(response.content)
permissions = js.get('permissions', dict())
if (isinstance(permissions, unicode) or isinstance(permissions, str)):
permissions = json.loads(permissions)
self.assertDictEqual(permissions['groups'], {})
|
'Tests creating a group through the group_create route.'
| def test_create_new_group(self):
| d = dict(title='TestGroup', description='This is a test group.', access='public', keywords='testing, groups')
self.client.login(username='admin', password='admin')
response = self.client.post(reverse('group_create'), data=d)
self.assertEqual(response.status_code, 302)
self.assertTrue(GroupProfile.objects.get(title='TestGroup'))
|
'Tests deleting a group through the group_delete route.'
| def test_delete_group_view(self):
| self.assertTrue(GroupProfile.objects.get(id=self.bar.id))
self.client.login(username='admin', password='admin')
response = self.client.post(reverse('group_remove', args=[self.bar.slug]))
self.assertEqual(response.status_code, 302)
self.assertFalse((GroupProfile.objects.filter(id=self.bar.id).count() > 0))
|
'Tests deleting a group through the group_delete with a non-manager.'
| def test_delete_group_view_no_perms(self):
| self.assertTrue(GroupProfile.objects.get(id=self.bar.id))
self.client.login(username='norman', password='norman')
response = self.client.post(reverse('group_remove', args=[self.bar.slug]))
self.assertEqual(response.status_code, 403)
self.assertTrue(GroupProfile.objects.get(id=self.bar.id))
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.