def get_attribute(self, instance):
try:
func = getattr(instance, f"get_{self.type}_url")
return build_absolute_uri(func())
except AttributeError as e:
logger.exception(e)
return None
def test_embed_urls(self):
"""
Ensure the embed urls reflect the concrete instance ones.
"""
# Admin
self.assertTrue(self.client.login(username='******', password='******'))
resources = ResourceBase.objects.all()
for resource in resources:
url = reverse('base-resources-detail', kwargs={'pk': resource.pk})
response = self.client.get(url, format='json')
if resource.title.endswith('metadata true'):
self.assertEqual(response.status_code, 404)
else:
self.assertEqual(response.status_code, 200)
self.assertEqual(int(response.data['resource']['pk']), int(resource.pk))
embed_url = response.data['resource']['embed_url']
self.assertIsNotNone(embed_url)
instance = resource.get_real_instance()
if hasattr(instance, 'embed_url'):
if instance.embed_url != NotImplemented:
self.assertEqual(build_absolute_uri(instance.embed_url), embed_url)
else:
self.assertEqual("", embed_url)
def get_attribute(self, instance):
_instance = instance.get_real_instance()
if hasattr(_instance,
'embed_url') and _instance.embed_url != NotImplemented:
return build_absolute_uri(_instance.embed_url)
else:
return ""
def logo_url(self):
_missing_thumbnail_url = static(MISSING_THUMB)
try:
_base_path = os.path.split(self.logo.path)[0]
_upload_path = os.path.split(self.logo.url)[1]
_upload_path = os.path.join(_base_path, _upload_path)
if not os.path.exists(_upload_path):
copyfile(self.logo.path, _upload_path)
except Exception as e:
logger.debug(e)
_url = None
try:
_url = self.logo.url
except Exception as e:
logger.debug(e)
return build_absolute_uri(_missing_thumbnail_url)
return build_absolute_uri(_url)
def get_attribute(self, instance):
thumbnail_url = instance.thumbnail_url
if hasattr(instance, 'curatedthumbnail'):
try:
if hasattr(instance.curatedthumbnail.img_thumbnail, 'url'):
thumbnail_url = instance.curatedthumbnail.thumbnail_url
except Exception as e:
logger.exception(e)
return build_absolute_uri(thumbnail_url)
def to_representation(self, instance):
data = super().to_representation(instance)
try:
path = reverse(self.Meta.view_name)
if not path.endswith('/'):
path = f"{path}/"
url = urljoin(path, str(instance.pk))
data['link'] = build_absolute_uri(url)
except NoReverseMatch as e:
logger.exception(e)
return data
def get_attribute(self, instance):
try:
_instance = instance.get_real_instance()
except Exception as e:
logger.exception(e)
_instance = None
if _instance and hasattr(
_instance,
'embed_url') and _instance.embed_url != NotImplemented:
return build_absolute_uri(_instance.embed_url)
else:
return ""
def get_attribute(self, instance):
return build_absolute_uri(instance.detail_url)
def get_attribute(self, instance):
return build_absolute_uri(avatar_url(instance, self.avatar_size))
def compact(self):
"""Converts a standard and verbose 'perm_spec' into 'compact mode'.
- The method also recognizes special/internal security groups, like 'anonymous' and 'registered-members' and places
their permissions on a specific node called 'groups'.
- Every security group, different from the former ones, associated to a GeoNode 'GroupProfile', will be placed on a
node called 'organizations' instead.
e.g.:
```
{
"users": [
{
"id": 1001,
"username": "******",
"first_name": "",
"last_name": "",
"avatar": "",
"permissions": "manage",
"is_superuser": <bool>,
"is_staff": <bool>
}
],
"organizations": [],
"groups": [
{
"id": 3,
"title": "Registered Members",
"name": "registered-members",
"permissions": "edit"
},
{
"id": 2,
"title": "anonymous",
"name": "anonymous",
"permissions": "download"
}
]
}
```
"""
json = {}
user_perms = []
group_perms = []
anonymous_perms = None
contributors_perms = None
organization_perms = []
for _k in self.users:
_perms = self.users[_k]
if isinstance(_k, str):
_k = get_user_model().objects.get(username=_k)
if not _k.is_anonymous and _k.username != 'AnonymousUser':
avatar = build_absolute_uri(avatar_url(_k, 240))
user = _User(_k.id, _k.username, _k.last_name, _k.first_name,
avatar, _k.is_superuser, _k.is_staff)
is_owner = _k == self._resource.owner
user_perms.append({
'id':
user.id,
'username':
user.username,
'first_name':
user.first_name,
'last_name':
user.last_name,
'avatar':
user.avatar,
'permissions':
_to_compact_perms(_perms, self._resource.resource_type,
self._resource.subtype, is_owner),
'is_superuser':
user.is_superuser,
'is_staff':
user.is_staff
})
else:
anonymous_perms = {
'id':
Group.objects.get(name='anonymous').id,
'title':
'anonymous',
'name':
'anonymous',
'permissions':
_to_compact_perms(_perms, self._resource.resource_type,
self._resource.subtype)
}
# Let's make sure we don't lose control over the resource
if not any([
_u.get('id', None) == self._resource.owner.id
for _u in user_perms
]):
user_perms.append({
'id':
self._resource.owner.id,
'username':
self._resource.owner.username,
'first_name':
self._resource.owner.first_name,
'last_name':
self._resource.owner.last_name,
'avatar':
build_absolute_uri(avatar_url(self._resource.owner, 240)),
'permissions':
OWNER_RIGHTS,
'is_superuser':
self._resource.owner.is_superuser,
'is_staff':
self._resource.owner.is_staff
})
for user in get_user_model().objects.filter(is_superuser=True):
if not any([_u.get('id', None) == user.id for _u in user_perms]):
user_perms.append({
'id':
user.id,
'username':
user.username,
'first_name':
user.first_name,
'last_name':
user.last_name,
'avatar':
build_absolute_uri(avatar_url(user, 240)),
'permissions':
MANAGE_RIGHTS,
'is_superuser':
user.is_superuser,
'is_staff':
user.is_staff
})
for _k in self.groups:
_perms = self.groups[_k]
if isinstance(_k, str):
_k = Group.objects.get(name=_k)
if _k.name == 'anonymous':
anonymous_perms = {
'id':
_k.id,
'title':
'anonymous',
'name':
'anonymous',
'permissions':
_to_compact_perms(_perms, self._resource.resource_type,
self._resource.subtype)
}
elif hasattr(_k, 'groupprofile'):
group = _Group(_k.id, _k.groupprofile.title, _k.name,
_k.groupprofile.logo_url)
if _k.name == groups_settings.REGISTERED_MEMBERS_GROUP_NAME:
contributors_perms = {
'id':
group.id,
'title':
group.title,
'name':
group.name,
'permissions':
_to_compact_perms(_perms, self._resource.resource_type,
self._resource.subtype)
}
else:
organization_perms.append({
'id':
group.id,
'title':
group.title,
'name':
group.name,
'logo':
group.logo,
'permissions':
_to_compact_perms(_perms, self._resource.resource_type,
self._resource.subtype)
})
if anonymous_perms:
group_perms.append(anonymous_perms)
else:
anonymous_group = Group.objects.get(name='anonymous')
group_perms.append({
'id':
anonymous_group.id,
'title':
'anonymous',
'name':
'anonymous',
'permissions':
_to_compact_perms(
get_group_perms(anonymous_group, self._resource),
self._resource.resource_type, self._resource.subtype)
})
if contributors_perms:
group_perms.append(contributors_perms)
elif Group.objects.filter(
name=groups_settings.REGISTERED_MEMBERS_GROUP_NAME).exists():
contributors_group = Group.objects.get(
name=groups_settings.REGISTERED_MEMBERS_GROUP_NAME)
group_perms.append({
'id':
contributors_group.id,
'title':
'Registered Members',
'name':
contributors_group.name,
'permissions':
_to_compact_perms(
get_group_perms(contributors_group, self._resource),
self._resource.resource_type, self._resource.subtype)
})
json['users'] = user_perms
json['organizations'] = organization_perms
json['groups'] = group_perms
return json.copy()
def get_attribute(self, instance):
thumbnail_url = instance.thumbnail_url
return build_absolute_uri(thumbnail_url)
def download_url(self):
return build_absolute_uri(
reverse('document_download', args=(self.id, )))
