def test_js_inserted_resource_view(self):
from nose import SkipTest
raise SkipTest("Test won't work until CKAN 1.5.2")
from ckan.logic.action import get
from ckan import model
context = {"model": model, "ignore_auth": True}
data = {"id": "annakarenina"}
pkg = get.package_show(context, data)
resource_id = pkg["resources"][0]["id"]
command = LoadAnalytics("loadanalytics")
command.TEST_HOST = MockClient("localhost", 6969)
command.CONFIG = self.config
command.run([])
response = self.app.get(
url_for(
controller="package",
action="resource_read",
id="annakarenina",
resource_id=resource_id,
))
assert 'onclick="javascript: _gaq.push(' in response.body
def restricted_package_show(context, data_dict):
package_metadata = package_show(context, data_dict)
# Ensure user who can edit can see the resource
if authz.is_authorized('package_update', context,
package_metadata).get('success', False):
return package_metadata
# Custom authorization
if isinstance(package_metadata, dict):
restricted_package_metadata = dict(package_metadata)
else:
restricted_package_metadata = dict(package_metadata.for_json())
# restricted_package_metadata['resources'] = _restricted_resource_list_url(
# context, restricted_package_metadata.get('resources', []))
restricted_package_metadata[
'resources'] = _restricted_resource_list_hide_fields(
context, restricted_package_metadata.get('resources', []))
restricted_package_metadata['resources'] = filter(
lambda x: x.get('restricted', '') == '' or json.loads(x['restricted'])[
'level'] == 'public',
restricted_package_metadata.get('resources', []))
restricted_package_metadata['num_resources'] = len(
restricted_package_metadata['resources'])
return (restricted_package_metadata)
def _create_or_update_package(self,package_dict,harvest_object):
'''
Creates a new package or updates an exisiting one according to the
package dictionary provided. The package dictionary should look like
the REST API response for a package:
http://ckan.net/api/rest/package/statistics-catalunya
Note that the package_dict must contain an id, which will be used to
check if the package needs to be created or updated (use the remote
dataset id).
If the remote server provides the modification date of the remote
package, add it to package_dict['metadata_modified'].
'''
try:
#from pprint import pprint
#pprint(package_dict)
## change default schema
schema = default_package_schema()
schema["id"] = [ignore_missing, unicode]
context = {
'model': model,
'session':Session,
'user': u'harvest',
'api_version':'2',
'schema': schema,
}
# Check if package exists
context.update({'id':package_dict['id']})
try:
existing_package_dict = package_show(context)
# Check modified date
if not 'metadata_modified' in package_dict or \
package_dict['metadata_modified'] > existing_package_dict['metadata_modified']:
log.info('Package with GUID %s exists and needs to be updated' % harvest_object.guid)
# Update package
updated_package = package_update_rest(package_dict,context)
harvest_object.package_id = updated_package['id']
harvest_object.save()
else:
log.info('Package with GUID %s not updated, skipping...' % harvest_object.guid)
except NotFound:
# Package needs to be created
del context['id']
log.info('Package with GUID %s does not exist, let\'s create it' % harvest_object.guid)
new_package = package_create_rest(package_dict,context)
harvest_object.package_id = new_package['id']
harvest_object.save()
return True
except ValidationError,e:
log.exception(e)
self._save_object_error('Invalid package with GUID %s: %r'%(harvest_object.guid,e.error_dict),harvest_object,'Import')
def package_show_minimal(context, data_dict):
'''Return the metadata of a dataset (package) and its resources.
:param id: the id or name of the dataset
:type id: string
:param use_default_schema: use default package schema instead of
a custom schema defined with an IDatasetForm plugin (default: False)
:type use_default_schema: bool
:rtype: dictionary
'''
package = get.package_show(context, data_dict)
if check_logged_in(context):
fulltext = _get_fulltext(package['id'])
if fulltext:
fulltext_dict = { 'key': 'full_text_search',
'value': fulltext.text
}
package['extras'].append(fulltext_dict)
return package
minimal_package = _del_extra_field_from_dict(package)
minimal_package = _del_main_field_from_dict(minimal_package)
return minimal_package
def edit(self, id, data=None, errors=None, error_summary=None):
context = {'model': model, 'session': model.Session,
'user': c.user or c.author, 'extras_as_string': True,
'preview': 'preview' in request.params,
'save': 'save' in request.params,
'moderated': config.get('moderated'),
'pending': True,
'schema': self._form_to_db_schema()}
if (context['save'] or context['preview']) and not data:
return self._save_edit(id, context)
try:
old_data = get.package_show(context, {'id':id})
schema = self._db_to_form_schema()
if schema:
old_data, errors = validate(old_data, schema)
data = data or old_data
except NotAuthorized:
abort(401, _('Unauthorized to read package %s') % '')
except NotFound:
abort(404, _('Package not found'))
c.pkg = context.get("package")
am_authz = self.authorizer.am_authorized(c, model.Action.EDIT, c.pkg)
if not am_authz:
abort(401, _('User %r not authorized to edit %s') % (c.user, id))
errors = errors or {}
vars = {'data': data, 'errors': errors, 'error_summary': error_summary}
self._setup_template_variables(context, {'id':'id'})
c.form = render(self.package_form, extra_vars=vars)
return render('package/edit.html')
def restricted_package_show(context, data_dict, package_metadata=None):
hide_inaccessible_resources = p.toolkit.asbool(data_dict.get('hide_inaccessible_resources', False))
if not package_metadata:
package_metadata = package_show(context, data_dict)
# Ensure user who can edit can see the resource
if authz.is_authorized(
'package_update', context, package_metadata).get('success', False):
return package_metadata
# Custom authorization
if isinstance(package_metadata, dict):
restricted_package_metadata = dict(package_metadata)
else:
restricted_package_metadata = dict(package_metadata.for_json())
# restricted_package_metadata['resources'] = _restricted_resource_list_url(
# context, restricted_package_metadata.get('resources', []))
resources = restricted_package_metadata.get('resources', [])
if hide_inaccessible_resources:
resources = _restricted_resource_list_accessible_by_user(context, resources, package_dict=package_metadata)
restricted_package_metadata['num_resources'] = len(resources)
resources = _restricted_resource_list_hide_fields(context, resources)
restricted_package_metadata['resources'] = resources
return (restricted_package_metadata)
def package_show(context, data_dict):
package_dict = get.package_show(context, data_dict)
package = Package.get(package_dict['id'])
package_dict['ratings'] = package.get_average_rating()
# if package_dict['type'] == 'dataset':
# send_log(context, package_dict, 'Dataset metadata accessed',
# 'DatasetMetadataAccessed')
return package_dict
def package_show(context, data_dict):
''' This action is overriden so that the extra field "theme" is added.
This is needed because when a dataset is exposed to DCAT it needs this
field.
Themes are coming from groups where a dataset is added to. The field
"theme" exists in group's schema.'''
result = get_core.package_show(context, data_dict)
dataset_id = result.get('id')
owner_org = result.get('owner_org')
model = context.get('model')
package = model.Package.get(dataset_id)
if package.type == 'showcase':
return result
groups = package.get_groups(group_type='group')
result = result.copy()
extras = result.get('extras')
extra_theme_found = False
extra_publisher_email_found = False
extra_publisher_url_found = False
if extras:
for extra in extras:
if extra.get('key') == 'publisher_email':
extra_publisher_email_found = True
data_dict = {'id': owner_org}
org = toolkit.get_action('organization_show')({}, data_dict)
organization_email = org.get('organization_email')
extra['value'] = organization_email
if extra.get('key') == 'publisher_url':
extra_publisher_url_found = True
publisher_url = h.url_for(controller='organization',
action='read',
id=owner_org,
qualified=True)
extra['value'] = publisher_url
return result
else:
result.update({'extras': []})
extras = result.get('extras')
org = toolkit.get_action('organization_show')({}, {'id': owner_org})
organization_email = org.get('organization_email')
if organization_email:
extras.append({'key': 'publisher_email', 'value': organization_email})
return result
def test_basic(self):
# Create new records
added, updated, warnings, errors = self.assert_csv_import('from_the_registry.csv',3,0,0,0)
# Check that packages were actually created
pkgs = package_list(self.context,{})
assert len(pkgs) == 3
# Update existing records and create a new one
added, updated, warnings, errors = self.assert_csv_import('from_the_registry_update.csv',1,3,0,0)
# Check that packages were updated and the new one created
pkgs = package_list(self.context,{})
assert len(pkgs) == 4
pkg = package_show(self.context,{'id':'test-publisher-vu'})
assert 'UPDATED' in pkg['title']
pkg = package_show(self.context,{'id':'test-publisher-iq'})
assert 'NEW' in pkg['title']
def package_show(context, data_dict):
'''
Wraps the default package_show and adds additional information to the resources:
resource size (for uploaded files) and resource revision timestamp
'''
# data_dict['include_tracking'] = True
package_dict = logic_get.package_show(context, data_dict)
_additional_hdx_package_show_processing(context, package_dict)
return package_dict
def test_basic(self):
# Create new records
added, updated, warnings, errors = self.assert_csv_import('from_the_registry.csv',3,0,0,0)
# Check that packages were actually created
pkgs = package_list(self.context,{})
assert len(pkgs) == 3
# Update existing records and create a new one
added, updated, warnings, errors = self.assert_csv_import('from_the_registry_update.csv',1,3,0,0)
# Check that packages were updated and the new one created
pkgs = package_list(self.context,{})
assert len(pkgs) == 4
pkg = package_show(self.context,{'id':'test-publisher-vu'})
assert 'UPDATED' in pkg['title']
pkg = package_show(self.context,{'id':'test-publisher-iq'})
assert 'NEW' in pkg['title']
def request_resource(context, data_dict):
'''Sent Email with a resource request to the owner of a dataset.'''
contact_email = data_dict.get('contact_email')
owner_id = data_dict.get('creator_id')
resource_id = data_dict.get('resource_id')
resource_link = toolkit.url_for(
action='resource_read',
controller='package',
id=data_dict.get('package_name'),
resource_id=resource_id)
package = package_show(context, {'id':data_dict.get('package_name')})
dashboard_restricted = config.get(
'ckan.site_url') + '/dashboard/restricted'
# create request e-mail
extra_vars = {
'site_title': config.get('ckan.site_title'),
'site_url': config.get('ckan.site_url'),
'user_email': data_dict.get('email'),
'resource_name': data_dict.get('resource_name'),
'resource_link': config.get('ckan.site_url') + resource_link,
'package_name': data_dict.get('pkg_title'),
'message': data_dict.get('message', ''),
'dashboard_restricted': dashboard_restricted,
'admin_email_to': config.get('email_to', 'email_to_undefined')}
body = render_jinja2(
'restricted/emails/restricted_access_unauth_request.txt', extra_vars)
subject = \
_('Αίτημα πρόσβασης στο {0} από τον χρήστη {1}').format(
data_dict.get('resource_name'),
data_dict.get('email'))
# send e-mail
try:
ckan.lib.mailer.mail_recipient(data_dict.get('email'), contact_email,
subject, body)
except ckan.lib.mailer.MailerException:
success = False
# return 'Error sending e-mail'
request_dict = {'resource_id': resource_id, 'message': data_dict.get('message'),
'owner_id': owner_id, 'request_email': data_dict.get('email')
}
logic.save_restricted_request(request_dict)
# return _('Mail sent!')
data = {'resource_id': resource_id, 'maintainer_email': contact_email,
'user_email': data_dict.get('email'), 'package_title':data_dict.get('pkg_title'),
'message': data_dict.get('message')}
return render(
'restricted/restricted_request_access_result.html',
extra_vars={'data': data, 'pkg_dict': package, 'success': True})
def restricted_package_show(context, data_dict):
package_metadata = package_show(context, data_dict)
# Ensure user who can edit can see the resource
if authz.is_authorized('package_update', context,
package_metadata).get('success', False):
return package_metadata
# Custom authorization
restricted_package_metadata = package_metadata
restricted_package_metadata['resources'] = _restricted_resource_list_url(
context, restricted_package_metadata.get('resources', []))
return restricted_package_metadata
def package_create(context, data_dict):
if type(data_dict) is dict:
log.debug('Creating mapping...')
mapped_resources = []
if 'resources' in data_dict:
for resource in data_dict['resources']:
mapped_resource = generate_mapping(context, resource)
mapped_resources.append(mapped_resource)
data_dict['resources'] = mapped_resources
package_dict = create.package_create(context, data_dict)
package = None
if type(package_dict) is not dict:
package = get.package_show(context, {'id': package_dict})
else:
package = get.package_show(context, {'id': package_dict['id']})
if package is not None:
if package['type'] == 'dataset':
send_dataset_log(context, package, 'Dataset created',
'DatasetPublished')
update_de(package)
return package_dict
def show_package(context, data_dict):
# this function solves the missing value error
# when dataset schema is changed and we have old datasets
# that were created prior to the schema change
if context.get('for_view', None) or context.get('for_edit', None) or context.get('pending', None) or \
context.get('allow_partial_update', None):
context['validate'] = False
if context.get('resource', None):
model = context['model']
pkg = model.Package.get(data_dict['id'])
data_dict = model_dictize.package_dictize(pkg, context)
if check_if_dataset_using_older_schema(data_dict['extras']):
context['validate'] = False
return package_show(context, data_dict)
def test_resource_list(self):
# TODO restore this test. It doesn't make much sense with the
# present resource list design.
name = 'annakarenina'
cache_url = 'http://thedatahub.org/test_cache_url.csv'
# add a cache_url to the first resource in the package
context = {'model': model, 'session': model.Session, 'user': '******'}
data = {'id': 'annakarenina'}
pkg = get.package_show(context, data)
pkg['resources'][0]['cache_url'] = cache_url
# FIXME need to pretend to be called by the api
context['api_version'] = 3
update.package_update(context, pkg)
# check that the cache url is included on the dataset view page
offset = url_for(controller='package', action='read', id=name)
res = self.app.get(offset)
def _restricted_resource_list_accessible_by_user(context, resource_list, package_dict=None):
restricted_resources_list = []
user_name = logic.restricted_get_username_from_context(context)
user_obj = context.get('auth_user_obj')
for resource in resource_list:
resource_dict = dict(resource)
if not package_dict:
package_dict = package_show(context, {'id': resource_dict['package_id']})
user_has_resource_access = logic.restricted_check_user_resource_access(
user_name,
resource_dict,
package_dict,
user_obj=user_obj,
check_access_package_show=False,
user_organization_dict=logic.get_organization_dict(user_name)
).get('success', False)
if user_has_resource_access:
restricted_resources_list.append(resource_dict)
return restricted_resources_list
def read(self, id):
context = {'model': model, 'session': model.Session,
'user': c.user or c.author, 'extras_as_string': True,
'schema': self._form_to_db_schema()}
data_dict = {'id': id}
split = id.split('@')
if len(split) == 2:
data_dict['id'], revision = split
try:
date = datetime.datetime(*map(int, re.split('[^\d]', revision)))
context['revision_date'] = date
except ValueError:
context['revision_id'] = revision
#check if package exists
try:
c.pkg_dict = get.package_show(context, data_dict)
c.pkg = context['package']
except NotFound:
abort(404, _('Package not found'))
except NotAuthorized:
abort(401, _('Unauthorized to read package %s') % id)
cache_key = self._pkg_cache_key(c.pkg)
etag_cache(cache_key)
#set a cookie so we know whether to display the welcome message
c.hide_welcome_message = bool(request.cookies.get('hide_welcome_message', False))
response.set_cookie('hide_welcome_message', '1', max_age=3600) #(make cross-site?)
# used by disqus plugin
c.current_package_id = c.pkg.id
if config.get('rdf_packages'):
accept_header = request.headers.get('Accept', '*/*')
for content_type, exts in negotiate(autoneg_cfg, accept_header):
if "html" not in exts:
rdf_url = '%s%s.%s' % (config['rdf_packages'], c.pkg.id, exts[0])
redirect(rdf_url, code=303)
break
PackageSaver().render_package(c.pkg_dict, context)
return render('package/read.html')
def test_js_inserted_resource_view(self):
from nose import SkipTest
raise SkipTest("Test won't work until CKAN 1.5.2")
from ckan.logic.action import get
from ckan import model
context = {'model': model, 'ignore_auth': True}
data = {'id': 'annakarenina'}
pkg = get.package_show(context, data)
resource_id = pkg['resources'][0]['id']
command = LoadAnalytics("loadanalytics")
command.TEST_HOST = MockClient('localhost', 6969)
command.CONFIG = self.config
command.run([])
response = self.app.get(url_for(
controller='package', action='resource_read', id='annakarenina',
resource_id=resource_id
))
assert 'onclick="javascript: _gaq.push(' in response.body
def test_js_inserted_resource_view(self):
from nose import SkipTest
raise SkipTest("Test won't work until CKAN 1.5.2")
from ckan.logic.action import get
from ckan import model
context = {'model': model, 'ignore_auth': True}
data = {'id': 'annakarenina'}
pkg = get.package_show(context, data)
resource_id = pkg['resources'][0]['id']
command = LoadAnalytics("loadanalytics")
command.TEST_HOST = MockClient('localhost', 6969)
command.CONFIG = self.config
command.run([])
response = self.app.get(url_for(
controller='package', action='resource_read', id='annakarenina',
resource_id=resource_id
))
assert 'onclick="javascript: _gaq.push(' in response.body
def test_resource_list(self, app):
# TODO restore this test. It doesn't make much sense with the
# present resource list design.
name = "annakarenina"
cache_url = "http://thedatahub.org/test_cache_url.csv"
# add a cache_url to the first resource in the package
context = {
"model": model,
"session": model.Session,
"user": "******",
}
data = {"id": "annakarenina"}
pkg = get.package_show(context, data)
pkg["resources"][0]["cache_url"] = cache_url
# FIXME need to pretend to be called by the api
context["api_version"] = 3
update.package_update(context, pkg)
# check that the cache url is included on the dataset view page
offset = url_for("dataset.read", id=name)
res = app.get(offset)
def restricted_package_show(context, data_dict):
package_metadata = package_show(context, data_dict)
# Ensure user who can edit can see the resource
if authz.is_authorized('package_update', context,
package_metadata).get('success', False):
return package_metadata
# Custom authorization
if (type(package_metadata) == type(dict())):
restricted_package_metadata = dict(package_metadata)
else:
restricted_package_metadata = dict(package_metadata.for_json())
restricted_package_metadata[
'resources'] = _restricted_resource_list_hide_fields(
context, restricted_package_metadata.get('resources', []))
return (restricted_package_metadata)
def package_update(context, data_dict):
# The only thing we do here is remove some extras that are always
# inherited from the dataset publisher, to avoid duplicating them
_remove_extras_from_data_dict(data_dict)
old_package_dict = get_core.package_show(
context, {"id": data_dict.get('id') or data_dict.get('name')})
updated_package = update_core.package_update(context, data_dict)
# Part of first publisher date patch
if 'owner_org' in data_dict:
hlp.first_published_date_patch(updated_package.get('owner_org'))
if old_package_dict.get('private') and not updated_package.get('private') and \
updated_package.get('satte') != "deleted":
# Data is published send an email
package_title = updated_package.get('title') or updated_package.get(
'name')
send_data_published_notification(context,
updated_package.get('owner_org', ''),
package_title)
return updated_package
def read_ajax(self, id, revision=None):
context = {'model': model, 'session': model.Session,
'user': c.user or c.author,
'extras_as_string': True,
'schema': self._form_to_db_schema(),
'revision_id': revision}
try:
data = get.package_show(context, {'id': id})
schema = self._db_to_form_schema()
if schema:
data, errors = validate(data, schema)
except NotAuthorized:
abort(401, _('Unauthorized to read package %s') % '')
except NotFound:
abort(404, _('Package not found'))
## hack as db_to_form schema should have this
data['tag_string'] = ' '.join([tag['name'] for tag in data.get('tags', [])])
data.pop('tags')
data = flatten_to_string_key(data)
response.headers['Content-Type'] = 'application/json;charset=utf-8'
return json.dumps(data)
def comments(self, id):
context = {'model': model, 'session': model.Session,
'user': c.user or c.author, 'extras_as_string': True,
'schema': self._form_to_db_schema()}
#check if package exists
try:
c.pkg_dict = get.package_show(context, {'id':id})
c.pkg = context['package']
except NotFound:
abort(404, _('Package not found'))
except NotAuthorized:
abort(401, _('Unauthorized to read package %s') % id)
# used by disqus plugin
c.current_package_id = c.pkg.id
for item in self.extensions:
item.read(c.pkg)
#render the package
PackageSaver().render_package(c.pkg_dict)
return render('package/comments.html')
def package_show_minimal(context, data_dict):
'''Return the metadata of a dataset (package) and its resources.
:param id: the id or name of the dataset
:type id: string
:param use_default_schema: use default package schema instead of
a custom schema defined with an IDatasetForm plugin (default: False)
:type use_default_schema: bool
:rtype: dictionary
'''
package = get.package_show(context, data_dict)
if check_logged_in(context):
fulltext = _get_fulltext(package['id'])
if fulltext:
fulltext_dict = {'key': 'full_text_search', 'value': fulltext.text}
package['extras'].append(fulltext_dict)
return package
minimal_package = _del_extra_field_from_dict(package)
minimal_package = _del_main_field_from_dict(minimal_package)
return minimal_package
def package_show(context, data_dict):
'''
Wraps the default package_show and adds additional information to the resources:
resource size (for uploaded files) and resource revision timestamp
'''
# data_dict['include_tracking'] = True
package_dict = logic_get.package_show(context, data_dict)
# added because showcase schema validation is generating "ckan.lib.navl.dictization_functions.Missing"
if 'tracking_summary' in package_dict and not package_dict.get('tracking_summary'):
del package_dict['tracking_summary']
# this shouldn't be executed from showcases
if package_dict.get('type') == 'dataset' and not context.get('no_compute_extra_hdx_show_properties'):
member_list = get_action('hdx_member_list')(context, {'org_id': package_dict.get('owner_org')})
if member_list and not member_list.get('is_member'):
del package_dict['maintainer_email']
if 'resources' in package_dict:
# max_time = 0
# j = None
# i = 0
for resource_dict in package_dict.get('resources', []):
if _should_manually_load_property_value(context, resource_dict, 'size'):
resource_dict['size'] = _get_resource_filesize(resource_dict)
if _should_manually_load_property_value(context, resource_dict, 'revision_last_updated'):
resource_dict['revision_last_updated'] = _get_resource_revison_timestamp(resource_dict)
if _should_manually_load_property_value(context, resource_dict, 'hdx_rel_url'):
resource_dict['hdx_rel_url'] = _get_resource_hdx_relative_url(resource_dict)
# if _check_dataset_preview_selected_value(context, resource_dict, 'dataset_preview_enabled'):
# if resource_dict.get('dataset_preview_enabled') > max_time:
# max_time = resource_dict.get('dataset_preview_enabled')
# j = i
# package_dict['resources'][i]['dataset_preview_enabled'] = False
# i = i + 1
#
# if j is not None:
# package_dict['resources'][j]['dataset_preview_enabled'] = True
# downloads_list = (res['tracking_summary']['total'] for res in package_dict.get('resources', []) if
# res.get('tracking_summary', {}).get('total'))
# package_dict['total_res_downloads'] = sum(downloads_list)
if _should_manually_load_property_value(context, package_dict, 'total_res_downloads'):
total_res_downloads = jql.downloads_per_dataset_all_cached().get(package_dict['id'], 0)
log.debug('Dataset {} has {} downloads'.format(package_dict['id'], total_res_downloads))
package_dict['total_res_downloads'] = total_res_downloads
if _should_manually_load_property_value(context, package_dict, 'pageviews_last_14_days'):
pageviews_last_14_days = jql.pageviews_per_dataset_last_14_days_cached().get(package_dict['id'], 0)
log.debug('Dataset {} has {} page views in the last 14 days'.format(package_dict['id'], pageviews_last_14_days))
package_dict['pageviews_last_14_days'] = pageviews_last_14_days
if _should_manually_load_property_value(context, package_dict, 'has_quickcharts'):
package_dict['has_quickcharts'] = False
for resource_dict in package_dict.get('resources', []):
resource_views = get_action('resource_view_list')(context, {'id': resource_dict['id']}) or []
for view in resource_views:
if view.get("view_type") == 'hdx_hxl_preview':
package_dict['has_quickcharts'] = True
break
if _should_manually_load_property_value(context, package_dict, 'has_geodata'):
package_dict['has_geodata'] = False
for resource_dict in package_dict.get('resources', []):
if resource_dict.get('format') in GEODATA_FORMATS:
package_dict['has_geodata'] = True
break
if _should_manually_load_property_value(context, package_dict, 'has_showcases'):
package_dict['has_showcases'] = False
package_dict['num_of_showcases'] = 0
num_of_showcases = len(hdx_get_package_showcase_id_list(context, {'package_id': package_dict['id']}))
if num_of_showcases > 0:
package_dict['has_showcases'] = True
package_dict['num_of_showcases'] = num_of_showcases
return package_dict
def restricted_package_show(context, data_dict):
username = context.get('user')
auth_context = context.get('__auth_audit')
for_view = context.get('for_view')
# include_tracking flag is only true for frontend requests on /dataset?
include_tracking = data_dict.get('include_tracking')
# try:
# auth_context2 = context['__auth_audit']
# # logger.info('auth_context2: %s' % auth_context2)
# except:
# logger.error('No direct access to __auth_audit')
# logger.info('auth_context: %s' % auth_context)
skip_resource_auth_check = False
# if auth_context:
# dataset_flag = True
# The combination for_view=True with empty auth_audit seems to be only on /dataset page
if for_view and not auth_context:
skip_resource_auth_check = True
# if include_tracking:
# skip_resource_auth_check = True
try:
package_metadata = package_show(context, data_dict)
package_name = package_metadata.get('name')
logger.info(
u'User %s: restricted_package_show. Dataset: %s Context: ' %
(username, package_name))
print_context(context)
logger.debug('data_dict: %s' % data_dict)
# if dataset_flag:
# logger.info('Got request from /dataset. User %s: restricted_package_show. Dataset: %s' % (
# username, package_name))
# else:
# logger.info('Request WITHOUT __auth_audit. User %s: restricted_package_show. Dataset: %s Context follows: ' % (
# username, package_name))
# print_context(context)
# logger.info('User %s: restricted_package_show: %s' % (
# username, package_name))
# try:
# logger.info('User %s: restricted_package_show. Context: %s, Data: %s, Dataset: %s' % (
# username, context, data_dict, package_name))
# except:
# logger.error('Non-ASCII chars in context or data_dict. Ignore')
# pass
# Ensure the resource is visible to all users who have Edit rights
if authz.is_authorized('package_update', context,
package_metadata).get('success', False):
logger.info('User %s can UPDATE dataset: %s' %
(username, package_name))
return package_metadata
# Custom authorization
if isinstance(package_metadata, dict):
restricted_package_metadata = dict(package_metadata)
else:
restricted_package_metadata = dict(package_metadata.for_json())
if skip_resource_auth_check:
logger.warning(
'Request has for_view OR __auth_audit OR include_tracking. Skip checking each resource.'
)
else:
resource_list = restricted_package_metadata.get('resources', [])
logger.info(
'User %s does NOT have update rights. Checking access for %s resources'
% (username, len(resource_list)))
restricted_package_metadata[
'resources'] = _restricted_resource_list_hide_fields(
context,
resource_list,
package=restricted_package_metadata)
logger.info('Finished Checking access for %s resources' %
len(resource_list))
return (restricted_package_metadata)
except:
logger.error('Error in restricted_package_show')
logger.error(traceback.format_exc())
logger.warning(type(context))
logger.warning(u'data_dict: %s' % data_dict)
pass
def package_show(context, data_dict):
package_dict = get.package_show(context, data_dict)
package = Package.get(package_dict['id'])
package_dict['rating'] = package.get_average_rating()
return package_dict
def dgu_package_show(context, data_dict):
return remove_pii(package_show(context, data_dict))
