def read_dataset(self, _id, _format=None):
if not _format:
_format = check_access_header()
if not _format:
return PackageController().read(_id)
_profiles = toolkit.request.params.get('profiles')
if _profiles:
_profiles = _profiles.split(',')
toolkit.response.headers.update(
{'Content-type': CONTENT_TYPES[_format]})
try:
result = toolkit.get_action('dcat_dataset_show')(
{}, {
'id': _id,
'format': _format,
'profiles': _profiles
})
except toolkit.ObjectNotFound:
toolkit.abort(404)
return result
def resource_download(self, id, resource_id, filename=None):
self._post_analytics(c.user, "Resource", "Download", resource_id, id)
if is_using_cloudstorage:
use_controller = StorageController
use_class = StorageController()
else:
use_controller = PackageController
use_class = PackageController()
return use_controller.resource_download(use_class, id, resource_id,
filename)
def new_metadata(self):
"""
Process a dataset metadata submission and validate it. If valid, then proceed to add the dataset metadata and if not return the new_package_metadata page to display the errors so
the user can try to fix his submission.
"""
data = clean_dict(unflatten(tuplize_dict(parse_params(
request.params))))
result = toolkit.get_action('validate_dataset_metadata')(None, data)
vars = {"data": data}
if result['success'] == True:
return PackageController().new_metadata(id=data['pkg_name'])
else:
vars["errors"] = result["errors"]
return render('package/new_package_metadata.html', extra_vars=vars)
def resource_download(context, data):
check_and_bust('package_id', data)
check_and_bust('id', data)
# changing POST request to GET request
# needed because only GET request can return file
plugins.toolkit.request.environ['REQUEST_METHOD'] = 'GET'
package_id = data.get('package_id')
resource_id = data.get('id')
rsc = get_action('resource_show')(context, {'id': resource_id})
pkg = get_action('package_show')(context, {'id': package_id})
return PackageController().resource_download(package_id, resource_id)
def read_dataset(self, _id, _format=None):
log.debug('Leyendo dataset')
if not _format:
_format = check_access_header()
if not _format:
return PackageController().read(_id)
toolkit.response.headers.update(
{'Content-type': CONTENT_TYPES[_format]})
try:
result = toolkit.get_action('iaest_dataset_show')({}, {
'id': _id,
'format': _format
})
except toolkit.ObjectNotFound:
toolkit.abort(404)
return result
import json
from ckan import model
from ckan.plugins import toolkit
if toolkit.check_ckan_version(min_version='2.1'):
BaseController = toolkit.BaseController
else:
from ckan.lib.base import BaseController
if toolkit.check_ckan_version(max_version='2.8.99'):
from ckan.controllers.package import PackageController
from ckan.controllers.home import HomeController
read_endpoint = PackageController().read
index_endpoint = HomeController().index
else:
from ckan.views.home import index as index_endpoint
from ckan.views.dataset import read as read_endpoint
from ckanext.dcat.utils import CONTENT_TYPES, parse_accept_header
from ckanext.dcat.processors import RDFProfileException
def _get_package_type(id):
"""
Given the id of a package this method will return the type of the
package, or 'dataset' if no type is currently set
"""
pkg = model.Package.get(id)
if pkg:
return pkg.type or u'dataset'
def new(self, ds_id, ds_type):
new_payload = None
if 'save' not in request.params:
lc = ckanapi.LocalCKAN()
pkg = lc.action.package_show(id=ds_id)
pkg_id = pkg[PRODUCT_ID]
parent_schema = scheming_get_dataset_schema(pkg['type'])
new_payload = {
'type': ds_type,
'top_parent_id': pkg.get('top_parent_id', pkg_id) or pkg_id
}
id_payload = {
'parentProductId': pkg['product_id_new'],
'parentProduct': pkg['product_id_new'],
'productType': str(
parent_schema['dataset_type_code']
),
'productTypeCode': str(
parent_schema['dataset_type_code']
)
}
if ds_type == 'format':
new_payload['parent_id'] = pkg_id
elif ds_type == 'issue':
issue_number = next_issue_number(pkg_id)
issue_id = u'{pid}{issue_number}'.format(
pid=pkg_id,
issue_number=issue_number
)
new_payload['product_type_code'] = pkg.get('product_type_code')
new_payload['issue_number'] = issue_number
new_payload['product_id_new'] = issue_id
new_payload['name'] = u'issue-{issue_id}'.format(
issue_id=issue_id
)
pass
elif ds_type == 'article':
article_id = next_article_id(
pkg.get('top_parent_id', pkg_id) or pkg_id,
pkg.get('issue_number')
)
new_payload['product_type_code'] = pkg.get('product_type_code')
new_payload['issue_number'] = pkg.get('issue_number')
new_payload['product_id_new'] = article_id
new_payload['name'] = u'article-{article_id}'.format(
article_id=article_id
)
pass
elif ('non_data_product' in parent_schema and
parent_schema['non_data_product'] == True):
if is_legacy_product(pkg[PRODUCT_ID]):
new_payload[PRODUCT_ID] = lc.action.GetNextLegacyProductId(
**id_payload
)
else:
id_payload['subjectCode'] = pkg['subject_codes'][0]
new_payload[PRODUCT_ID] = lc.action.GetNextNonDataProductId(
**id_payload
)
else:
new_payload[PRODUCT_ID] = lc.action.GetNextProductId(
**id_payload
)
return PackageController().new(new_payload)
