def edit(self, id, data=None, errors=None, error_summary=None): package_type = self._get_package_type(id) context = {'model': model, 'session': model.Session, 'user': c.user, 'auth_user_obj': c.userobj, 'save': 'save' in request.params} if context['save'] and not data: return self._save_edit(id, context, package_type=package_type) try: c.pkg_dict = get_action('package_show')(dict(context, for_view=True), {'id': id}) context['for_edit'] = True old_data = get_action('package_show')(context, {'id': id}) # old data is from the database and data is passed from the # user if there is a validation error. Use users data if there. if data: old_data.update(data) data = old_data except (NotFound, NotAuthorized): abort(404, _('Dataset not found')) # are we doing a multiphase add? if data.get('state', '').startswith('draft'): c.form_action = h.url_for(controller='package', action='new') c.form_style = 'new' return self.new(data=data, errors=errors, error_summary=error_summary) c.pkg = context.get("package") c.resources_json = h.json.dumps(data.get('resources', [])) try: check_access('package_update', context) except NotAuthorized: abort(403, _('User %r not authorized to edit %s') % (c.user, id)) # convert tags if not supplied in data if data and not data.get('tag_string'): data['tag_string'] = ', '.join(h.dict_list_reduce( c.pkg_dict.get('tags', {}), 'name')) errors = errors or {} form_snippet = self._package_form(package_type=package_type) form_vars = {'data': data, 'errors': errors, 'error_summary': error_summary, 'action': 'edit', 'dataset_type': package_type, } c.errors_json = h.json.dumps(errors) self._setup_template_variables(context, {'id': id}, package_type=package_type) # we have already completed stage 1 form_vars['stage'] = ['active'] if data.get('state', '').startswith('draft'): form_vars['stage'] = ['active', 'complete'] edit_template = self._edit_template(package_type) return render(edit_template, extra_vars={'form_vars': form_vars, 'form_snippet': form_snippet, 'dataset_type': package_type})
def _save_edit(self, name_or_id, context, package_type=None): from ckan.lib.search import SearchIndexError log.debug('Package save request name: %s POST: %r', name_or_id, request.POST) try: data_dict = clean_dict( dict_fns.unflatten(tuplize_dict(parse_params(request.POST)))) self._validate_dataset(data_dict) if '_ckan_phase' in data_dict: # we allow partial updates to not destroy existing resources context['allow_partial_update'] = True if 'tag_string' in data_dict: data_dict['tags'] = self._tag_string_to_list( data_dict['tag_string']) del data_dict['_ckan_phase'] del data_dict['save'] context['message'] = data_dict.get('log_message', '') data_dict['id'] = name_or_id self.__generate_spatial_extra_field(data_dict) pkg = get_action('package_update')(context, data_dict) c.pkg = context['package'] c.pkg_dict = pkg self._form_save_redirect(pkg['name'], 'edit', package_type=package_type) except NotAuthorized: abort(403, _('Unauthorized to read package %s') % id) except NotFound, e: abort(404, _('Dataset not found'))
def _save_new(self, context, package_type=None): # The staged add dataset used the new functionality when the dataset is # partially created so we need to know if we actually are updating or # this is a real new. is_an_update = False ckan_phase = request.params.get('_ckan_phase') from ckan.lib.search import SearchIndexError try: data_dict = clean_dict(dict_fns.unflatten( tuplize_dict(parse_params(request.POST)))) if ckan_phase: # prevent clearing of groups etc context['allow_partial_update'] = True # sort the tags if 'tag_string' in data_dict: data_dict['tags'] = self._tag_string_to_list(data_dict['tag_string']) self._validate_dataset(data_dict) if data_dict.get('pkg_name'): is_an_update = True # This is actually an update not a save data_dict['id'] = data_dict['pkg_name'] del data_dict['pkg_name'] # don't change the dataset state data_dict['state'] = 'draft' # this is actually an edit not a save pkg_dict = get_action('package_update')(context, data_dict) if request.params['save'] == 'go-metadata': # redirect to add metadata url = h.url_for(controller='package', action='new_metadata', id=pkg_dict['name']) elif request.params['save'] == 'save-draft': url = h.url_for(controller='package', action='read', id=pkg_dict['name']) else: # redirect to add dataset resources url = h.url_for(controller='package', action='new_resource', id=pkg_dict['name']) redirect(url) # Make sure we don't index this dataset if request.params['save'] not in ['go-resource', 'go-metadata']: data_dict['state'] = 'draft' # allow the state to be changed context['allow_state_change'] = True data_dict['type'] = package_type context['message'] = data_dict.get('log_message', '') pkg_dict = get_action('package_create')(context, data_dict) if ckan_phase and request.params['save'] != 'save-draft': url = h.url_for(controller='package', action='new_resource', id=pkg_dict['name']) redirect(url) elif request.params['save'] == 'save-draft': url = h.url_for(controller='package', action='read', id=pkg_dict['name']) redirect(url) self._form_save_redirect(pkg_dict['name'], 'new', package_type=package_type) except NotAuthorized: abort(401, _('Unauthorized to read package %s') % '') except NotFound, e: abort(404, _('Dataset not found'))
def _save_new(self, context, package_type=None): # The staged add dataset used the new functionality when the dataset is # partially created so we need to know if we actually are updating or # this is a real new. is_an_update = False ckan_phase = request.params.get('_ckan_phase') from ckan.lib.search import SearchIndexError try: data_dict = clean_dict(dict_fns.unflatten( tuplize_dict(parse_params(request.POST)))) if ckan_phase: # prevent clearing of groups etc context['allow_partial_update'] = True # sort the tags if 'tag_string' in data_dict: data_dict['tags'] = self._tag_string_to_list(data_dict['tag_string']) if data_dict.get('pkg_name'): is_an_update = True # This is actually an update not a save data_dict['id'] = data_dict['pkg_name'] del data_dict['pkg_name'] # don't change the dataset state data_dict['state'] = 'draft' # this is actually an edit not a save pkg_dict = get_action('package_update')(context, data_dict) if request.params['save'] == 'go-metadata': # redirect to add metadata url = h.url_for(controller='package', action='new_metadata', id=pkg_dict['name']) elif request.params['save'] == 'save-draft': url = h.url_for(controller='package', action='read', id=pkg_dict['name']) else: # redirect to add dataset resources url = h.url_for(controller='package', action='new_resource', id=pkg_dict['name']) redirect(url) # Make sure we don't index this dataset if request.params['save'] not in ['go-resource', 'go-metadata']: data_dict['state'] = 'draft' # allow the state to be changed context['allow_state_change'] = True data_dict['type'] = package_type context['message'] = data_dict.get('log_message', '') pkg_dict = get_action('package_create')(context, data_dict) if ckan_phase and request.params['save'] != 'save-draft': url = h.url_for(controller='package', action='new_resource', id=pkg_dict['name']) redirect(url) elif request.params['save'] == 'save-draft': url = h.url_for(controller='package', action='read', id=pkg_dict['name']) redirect(url) self._form_save_redirect(pkg_dict['name'], 'new', package_type=package_type) except NotAuthorized: abort(401, _('Unauthorized to read package %s') % '') except NotFound, e: abort(404, _('Dataset not found'))
def _save_edit(self, name_or_id, context, package_type=None): from ckan.lib.search import SearchIndexError log.debug('Package save request name: %s POST: %r', name_or_id, request.POST) try: data_dict = clean_dict( dict_fns.unflatten(tuplize_dict(parse_params(request.POST)))) self._validate_dataset(data_dict) if '_ckan_phase' in data_dict: # we allow partial updates to not destroy existing resources context['allow_partial_update'] = True if 'tag_string' in data_dict: data_dict['tags'] = self._tag_string_to_list( data_dict['tag_string']) del data_dict['_ckan_phase'] del data_dict['save'] context['message'] = data_dict.get('log_message', '') data_dict['id'] = name_or_id # Obtengo la lista de extras del dataset y agrego en el data_dict los extras que falten # (no estaban en el request.POST), y reemplazo valores desactualizados extra_fields = get_action('package_show')(dict(context, for_view=True), { 'id': name_or_id })['extras'] if 'extras' not in data_dict.keys(): data_dict['extras'] = [] for extra_field in extra_fields: found_extra_field = filter( lambda x: x['key'] == extra_field['key'], data_dict['extras']) if len(found_extra_field) == 0: data_dict['extras'].append(extra_field) time_now = moment.now().isoformat() self._add_or_replace_extra(key='modified', value=time_now, extras=data_dict['extras']) self.__generate_spatial_extra_field(data_dict) pkg = get_action('package_update')(context, data_dict) c.pkg = context['package'] c.pkg_dict = pkg self._form_save_redirect(pkg['name'], 'edit', package_type=package_type) except NotAuthorized: abort(403, _('Unauthorized to read package %s') % id) except NotFound, e: abort(404, _('Dataset not found'))
def resource_edit(self, id, resource_id, data=None, errors=None, error_summary=None): context = { 'model': model, 'session': model.Session, 'api_version': 3, 'for_edit': True, 'user': c.user, 'auth_user_obj': c.userobj } data_dict = {'id': id} try: check_access('package_update', context, data_dict) except NotAuthorized: abort(403, _('User %r not authorized to edit %s') % (c.user, id)) if request.method == 'POST' and not data: data = data or \ clean_dict(dict_fns.unflatten(tuplize_dict(parse_params( request.POST)))) # we don't want to include save as it is part of the form del data['save'] # Guardo los campos issued y modified package_data = get_action('resource_show')(context, { 'id': resource_id }) # Los packages creados sin el campo extra "issued" deben defaultear al campo "created" issued = package_data.get('issued', None) or package_data.get('created') data['issued'] = issued data['modified'] = moment.now().isoformat() data['package_id'] = id try: if resource_id: data['id'] = resource_id get_action('resource_update')(context, data) else: get_action('resource_create')(context, data) except ValidationError, e: errors = e.error_dict error_summary = e.error_summary return self.resource_edit(id, resource_id, data, errors, error_summary) except NotAuthorized: abort(401, _('Unauthorized to edit this resource'))
def search(self): package_type = self._guess_package_type() try: context = {'model': model, 'user': c.user or c.author, 'auth_user_obj': c.userobj} check_access('site_read', context) except NotAuthorized: abort(401, _('Not authorized to see this page')) q = c.q = request.params.get('q', u'') c.query_error = False page = self._get_page_number(request.params) limit = g.datasets_per_page params_nopage = [(k, v) for k, v in request.params.items() if k != 'page'] def drill_down_url(alternative_url=None, **by): return h.add_url_param( alternative_url=alternative_url, controller='package', action='search', new_params=by ) c.drill_down_url = drill_down_url def remove_field(key, value=None, replace=None): return h.remove_url_param(key, value=value, replace=replace, controller='package', action='search') c.remove_field = remove_field sort_by = request.params.get('sort', None) params_nosort = [(k, v) for k, v in params_nopage if k != 'sort'] def _sort_by(fields): params = params_nosort[:] if fields: sort_string = ', '.join('%s %s' % f for f in fields) params.append(('sort', sort_string)) return search_url(params, package_type) c.sort_by = _sort_by if not sort_by: c.sort_by_fields = [] else: c.sort_by_fields = [field.split()[0] for field in sort_by.split(',')] def pager_url(q=None, page=None): params = list(params_nopage) params.append(('page', page)) return search_url(params, package_type) c.search_url_params = urlencode(_encode_params(params_nopage)) try: c.fields = [] c.fields_grouped = {} search_extras = {} fq = '' for (param, value) in request.params.items(): if param not in ['q', 'page', 'sort'] \ and len(value) and not param.startswith('_'): if not param.startswith('ext_'): c.fields.append((param, value)) if param != 'organization': fq += ' %s:"%s"' % (param, value) else: fq += custom_organization_filter(value) if param not in c.fields_grouped: c.fields_grouped[param] = [value] else: c.fields_grouped[param].append(value) else: search_extras[param] = value context = {'model': model, 'session': model.Session, 'user': c.user or c.author, 'for_view': True, 'auth_user_obj': c.userobj} if package_type and package_type != 'dataset': fq += ' +dataset_type:{type}'.format(type=package_type) elif not asbool(config.get('ckan.search.show_all_types', 'False')): fq += ' +dataset_type:dataset' facets = OrderedDict() default_facet_titles = { 'organization': _('Organizations'), 'groups': _('Groups'), 'tags': _('Tags'), 'res_format': _('Formats'), 'license_id': _('Licenses'), } for facet in g.facets: if facet in default_facet_titles: facets[facet] = default_facet_titles[facet] else: facets[facet] = facet for plugin in p.PluginImplementations(p.IFacets): facets = plugin.dataset_facets(facets, package_type) c.facet_titles = facets data_dict = { 'q': q, 'fq': fq.strip(), 'facet.field': facets.keys(), 'rows': limit, 'start': (page - 1) * limit, 'sort': sort_by, 'extras': search_extras } query = get_action('package_search')(context, data_dict) c.sort_by_selected = query['sort'] c.page = h.Page( collection=query['results'], page=page, url=pager_url, item_count=query['count'], items_per_page=limit ) c.facets = query['facets'] c.search_facets = query['search_facets'] c.page.items = query['results'] except SearchError, se: log.error('Dataset search error: %r', se.args) c.query_error = True c.facets = {} c.search_facets = {} c.page = h.Page(collection=[])
def new(self, data=None, errors=None, error_summary=None): if data and 'type' in data: package_type = data['type'] else: package_type = self._guess_package_type(True) context = {'model': model, 'session': model.Session, 'user': c.user or c.author, 'auth_user_obj': c.userobj, 'save': 'save' in request.params} # Package needs to have a organization group in the call to # check_access and also to save it try: check_access('package_create', context) except NotAuthorized: abort(401, _('Unauthorized to create a package')) if context['save'] and not data: return self._save_new(context, package_type=package_type) data = data or clean_dict(dict_fns.unflatten(tuplize_dict(parse_params( request.params, ignore_keys=CACHE_PARAMETERS)))) c.resources_json = h.json.dumps(data.get('resources', [])) # convert tags if not supplied in data if data and not data.get('tag_string'): data['tag_string'] = ', '.join( h.dict_list_reduce(data.get('tags', {}), 'name')) errors = errors or {} error_summary = error_summary or {} # in the phased add dataset we need to know that # we have already completed stage 1 stage = ['active'] if data.get('state', '').startswith('draft'): stage = ['active', 'complete'] # if we are creating from a group then this allows the group to be # set automatically data['group_id'] = request.params.get('group') or \ request.params.get('groups__0__id') form_snippet = self._package_form(package_type=package_type) form_vars = {'data': data, 'errors': errors, 'error_summary': error_summary, 'action': 'new', 'stage': stage, 'dataset_type': package_type, } c.errors_json = h.json.dumps(errors) self._setup_template_variables(context, {}, package_type=package_type) new_template = self._new_template(package_type) c.form = deprecated_lazy_render( new_template, form_snippet, lambda: render(form_snippet, extra_vars=form_vars), 'use of c.form is deprecated. please see ' 'ckan/templates/package/base_form_page.html for an example ' 'of the new way to include the form snippet' ) return render(new_template, extra_vars={'form_vars': form_vars, 'form_snippet': form_snippet, 'dataset_type': package_type})
context['message'] = data_dict.get('log_message', '') pkg_dict = get_action('package_create')(context, data_dict) if ckan_phase and request.params['save'] != 'save-draft': url = h.url_for(controller='package', action='new_resource', id=pkg_dict['name']) redirect(url) elif request.params['save'] == 'save-draft': url = h.url_for(controller='package', action='read', id=pkg_dict['name']) redirect(url) self._form_save_redirect(pkg_dict['name'], 'new', package_type=package_type) except NotAuthorized: abort(401, _('Unauthorized to read package %s') % '') except NotFound, e: abort(404, _('Dataset not found')) except dict_fns.DataError: abort(400, _(u'Integrity Error')) except SearchIndexError, e: try: exc_str = unicode(repr(e.args)) except Exception: # We don't like bare excepts exc_str = unicode(str(e)) abort(500, _(u'Unable to add package to search index.') + exc_str) except ValidationError, e: errors = e.error_dict error_summary = e.error_summary if is_an_update: # we need to get the state of the dataset to show the stage we # are on. pkg_dict = get_action('package_show')(context, data_dict) data_dict['state'] = pkg_dict['state'] return self.edit(data_dict['id'], data_dict,
def search(self): package_type = self._guess_package_type() try: context = { 'model': model, 'user': c.user or c.author, 'auth_user_obj': c.userobj } check_access('site_read', context) except NotAuthorized: abort(401, _('Not authorized to see this page')) q = c.q = request.params.get('q', u'') c.query_error = False page = self._get_page_number(request.params) limit = g.datasets_per_page params_nopage = [(k, v) for k, v in request.params.items() if k != 'page'] def drill_down_url(alternative_url=None, **by): return h.add_url_param(alternative_url=alternative_url, controller='package', action='search', new_params=by) c.drill_down_url = drill_down_url def remove_field(key, value=None, replace=None): return h.remove_url_param(key, value=value, replace=replace, controller='package', action='search') c.remove_field = remove_field sort_by = request.params.get('sort', None) params_nosort = [(k, v) for k, v in params_nopage if k != 'sort'] def _sort_by(fields): params = params_nosort[:] if fields: sort_string = ', '.join('%s %s' % f for f in fields) params.append(('sort', sort_string)) return search_url(params, package_type) c.sort_by = _sort_by if not sort_by: c.sort_by_fields = [] else: c.sort_by_fields = [ field.split()[0] for field in sort_by.split(',') ] def pager_url(q=None, page=None): params = list(params_nopage) params.append(('page', page)) return search_url(params, package_type) c.search_url_params = urlencode(_encode_params(params_nopage)) try: c.fields = [] c.fields_grouped = {} search_extras = {} fq = '' for (param, value) in request.params.items(): if param not in ['q', 'page', 'sort'] \ and len(value) and not param.startswith('_'): if not param.startswith('ext_'): c.fields.append((param, value)) if param != 'organization': fq += ' %s:"%s"' % (param, value) else: fq += custom_organization_filter(value) if param not in c.fields_grouped: c.fields_grouped[param] = [value] else: c.fields_grouped[param].append(value) else: search_extras[param] = value context = { 'model': model, 'session': model.Session, 'user': c.user or c.author, 'for_view': True, 'auth_user_obj': c.userobj } if package_type and package_type != 'dataset': fq += ' +dataset_type:{type}'.format(type=package_type) elif not asbool(config.get('ckan.search.show_all_types', 'False')): fq += ' +dataset_type:dataset' facets = OrderedDict() default_facet_titles = { 'organization': _('Organizations'), 'groups': _('Groups'), 'tags': _('Tags'), 'res_format': _('Formats'), 'license_id': _('Licenses'), } for facet in g.facets: if facet in default_facet_titles: facets[facet] = default_facet_titles[facet] else: facets[facet] = facet for plugin in p.PluginImplementations(p.IFacets): facets = plugin.dataset_facets(facets, package_type) c.facet_titles = facets data_dict = { 'q': q, 'fq': fq.strip(), 'facet.field': facets.keys(), 'rows': limit, 'start': (page - 1) * limit, 'sort': sort_by, 'extras': search_extras } query = get_action('package_search')(context, data_dict) c.sort_by_selected = query['sort'] c.page = h.Page(collection=query['results'], page=page, url=pager_url, item_count=query['count'], items_per_page=limit) c.facets = query['facets'] c.search_facets = query['search_facets'] c.page.items = query['results'] except SearchError, se: log.error('Dataset search error: %r', se.args) c.query_error = True c.facets = {} c.search_facets = {} c.page = h.Page(collection=[])
class GobArPackageController(PackageController): def __generate_spatial_extra_field(self, data_dict): extras = data_dict['extras'] def __find_extra(extras, key, create=False): for extra in extras: if extra['key'] == key: return extra if create: extra = {'key': key} extras.append(extra) return extra country = __find_extra(extras, 'country') if country: spatial = __find_extra(extras, 'spatial', True) spatial['value'] = [country['value']] province = __find_extra(extras, 'province') if province and province['value']: spatial['value'].append(province['value']) district = __find_extra(extras, 'district') if district and district['value']: spatial['value'].append(district['value']) spatial['value'] = ','.join(spatial['value']) def search(self): package_type = self._guess_package_type() try: context = { 'model': model, 'user': c.user or c.author, 'auth_user_obj': c.userobj } check_access('site_read', context) except NotAuthorized: abort(401, _('Not authorized to see this page')) q = c.q = request.params.get('q', u'') c.query_error = False page = self._get_page_number(request.params) limit = g.datasets_per_page params_nopage = [(k, v) for k, v in request.params.items() if k != 'page'] def drill_down_url(alternative_url=None, **by): return h.add_url_param(alternative_url=alternative_url, controller='package', action='search', new_params=by) c.drill_down_url = drill_down_url def remove_field(key, value=None, replace=None): return h.remove_url_param(key, value=value, replace=replace, controller='package', action='search') c.remove_field = remove_field sort_by = request.params.get('sort', None) params_nosort = [(k, v) for k, v in params_nopage if k != 'sort'] def _sort_by(fields): params = params_nosort[:] if fields: sort_string = ', '.join('%s %s' % f for f in fields) params.append(('sort', sort_string)) return search_url(params, package_type) c.sort_by = _sort_by if not sort_by: c.sort_by_fields = [] else: c.sort_by_fields = [ field.split()[0] for field in sort_by.split(',') ] def pager_url(q=None, page=None): params = list(params_nopage) params.append(('page', page)) return search_url(params, package_type) c.search_url_params = urlencode(_encode_params(params_nopage)) try: c.fields = [] c.fields_grouped = {} search_extras = {} fq = '' for (param, value) in request.params.items(): if param not in ['q', 'page', 'sort'] \ and len(value) and not param.startswith('_'): if not param.startswith('ext_'): c.fields.append((param, value)) if param != 'organization': fq += ' %s:"%s"' % (param, value) else: fq += custom_organization_filter(value) if param not in c.fields_grouped: c.fields_grouped[param] = [value] else: c.fields_grouped[param].append(value) else: search_extras[param] = value context = { 'model': model, 'session': model.Session, 'user': c.user or c.author, 'for_view': True, 'auth_user_obj': c.userobj } if package_type and package_type != 'dataset': fq += ' +dataset_type:{type}'.format(type=package_type) elif not asbool(config.get('ckan.search.show_all_types', 'False')): fq += ' +dataset_type:dataset' facets = OrderedDict() default_facet_titles = { 'organization': _('Organizations'), 'groups': _('Groups'), 'tags': _('Tags'), 'res_format': _('Formats'), 'license_id': _('Licenses'), } for facet in g.facets: if facet in default_facet_titles: facets[facet] = default_facet_titles[facet] else: facets[facet] = facet for plugin in p.PluginImplementations(p.IFacets): facets = plugin.dataset_facets(facets, package_type) c.facet_titles = facets data_dict = { 'q': q, 'fq': fq.strip(), 'facet.field': facets.keys(), 'rows': limit, 'start': (page - 1) * limit, 'sort': sort_by, 'extras': search_extras } query = get_action('package_search')(context, data_dict) c.sort_by_selected = query['sort'] c.page = h.Page(collection=query['results'], page=page, url=pager_url, item_count=query['count'], items_per_page=limit) c.facets = query['facets'] c.search_facets = query['search_facets'] c.page.items = query['results'] except SearchError, se: log.error('Dataset search error: %r', se.args) c.query_error = True c.facets = {} c.search_facets = {} c.page = h.Page(collection=[]) c.search_facets_limits = {} for facet in c.search_facets.keys(): try: if facet != 'organization': limit = int( request.params.get('_%s_limit' % facet, g.facets_default_number)) else: limit = None except ValueError: error_description = _( 'Parameter "{parameter_name}" is not an integer') error_description = error_description.format( parameter_name='_%s_limit' % facet) abort(400, error_description) c.search_facets_limits[facet] = limit maintain.deprecate_context_item('facets', 'Use `c.search_facets` instead.') self._setup_template_variables(context, {}, package_type=package_type) return render(self._search_template(package_type), extra_vars={'dataset_type': package_type})
def new_resource(self, id, data=None, errors=None, error_summary=None): ''' FIXME: This is a temporary action to allow styling of the forms. ''' if request.method == 'POST' and not data: save_action = request.params.get('save') data = data or clean_dict( dict_fns.unflatten(tuplize_dict(parse_params(request.POST)))) # we don't want to include save as it is part of the form del data['save'] resource_id = data['id'] del data['id'] self._validate_resource(data) context = { 'model': model, 'session': model.Session, 'user': c.user, 'auth_user_obj': c.userobj } if save_action == 'go-dataset': # go to first stage of add dataset h.redirect_to(controller='package', action='edit', id=id) # see if we have any data that we are trying to save data_provided = False for key, value in data.iteritems(): if ((value or isinstance(value, cgi.FieldStorage)) and key not in [ 'resource_type', 'license_id', 'attributesDescription' ]): data_provided = True break if not data_provided and save_action != "go-dataset-complete": if save_action == 'go-dataset': # go to first stage of add dataset h.redirect_to(controller='package', action='edit', id=id) try: data_dict = get_action('package_show')(context, {'id': id}) except NotAuthorized: abort(403, _('Unauthorized to update dataset')) except NotFound: abort( 404, _('The dataset {id} could not be found.').format( id=id)) if not len(data_dict['resources']): # no data so keep on page msg = _('You must add at least one data resource') # On new templates do not use flash message if asbool(config.get('ckan.legacy_templates')): h.flash_error(msg) h.redirect_to(controller='package', action='new_resource', id=id) else: errors = {} error_summary = {_('Error'): msg} return self.new_resource(id, data, errors, error_summary) # XXX race condition if another user edits/deletes data_dict = get_action('package_show')(context, {'id': id}) get_action('package_update')(dict(context, allow_state_change=True), dict(data_dict, state='active')) h.redirect_to(controller='package', action='read', id=id) data['package_id'] = id try: if resource_id: data['id'] = resource_id get_action('resource_update')(context, data) else: get_action('resource_create')(context, data) except ValidationError, e: errors = e.error_dict error_summary = e.error_summary return self.new_resource(id, data, errors, error_summary) except NotAuthorized: abort(403, _('Unauthorized to create a resource'))
def _save_new(self, context, package_type=None): # The staged add dataset used the new functionality when the dataset is # partially created so we need to know if we actually are updating or # this is a real new. is_an_update = False ckan_phase = request.params.get('_ckan_phase') from ckan.lib.search import SearchIndexError def pop_groups_from_data_dict_and_get_package_name_and_group_name( a_data_dict): # sacamos los grupos para que no fallen más adelante las validaciones de ckan some_group_names = [ group['name'] for group in ( a_data_dict['groups'] if 'groups' in a_data_dict else []) ] a_data_dict['groups'] = [] a_package_name = a_data_dict[ 'name'] # El campo Name identifica unívocamente a un Dataset return a_package_name, some_group_names def update_package_group_relation(a_package_name, group_names_to_add): # obtener id del package usando el a_package_name package = model.Package.get(a_package_name) # Es necesario eliminar *todos* los objetos `Member` que relacionan `Group`s con `Package`s # ya que vamos a reescribir esas relaciones según el parámetro `group_names_to_add` for group in model.Session.query(model.Group): # con el ID del package queriear los Member con table_id = package_id eliminar members_to_delete = model.Session.query(model.Member).filter( model.Member.group_id == group.id, model.Member.table_name == 'package', model.Member.table_id == package.id) for member in members_to_delete: model.Session.delete(member) model.Session.commit() # Hace falta el commit? # relaciono los datasets con los grupos correspondientes (que fueron ingresados) for group_name in group_names_to_add: group = model.Group.get(group_name) group.add_package_by_name(a_package_name) group.save() try: data_dict = clean_dict( dict_fns.unflatten(tuplize_dict(parse_params(request.POST)))) if ckan_phase: # prevent clearing of groups etc context['allow_partial_update'] = True # sort the tags if 'tag_string' in data_dict: data_dict['tags'] = self._tag_string_to_list( data_dict['tag_string']) self._validate_dataset(data_dict) # Limpiamos el data_dict para poder guardar el DS aun siendo colaborador no miembro del grupo package_name, group_names = pop_groups_from_data_dict_and_get_package_name_and_group_name( data_dict) if data_dict.get('pkg_name'): is_an_update = True # This is actually an update not a save data_dict['id'] = data_dict['pkg_name'] del data_dict['pkg_name'] # don't change the dataset state data_dict['state'] = 'draft' # this is actually an edit not a save pkg_dict = get_action('package_update')(context, data_dict) # Restauramos los grupos asignados al dataset (cuando es un update) update_package_group_relation(package_name, group_names) if request.params['save'] == 'go-metadata': # redirect to add metadata url = h.url_for(controller='package', action='new_metadata', id=pkg_dict['name']) elif request.params['save'] == 'save-draft': url = h.url_for(controller='package', action='read', id=pkg_dict['name']) else: # redirect to add dataset resources url = h.url_for(controller='package', action='new_resource', id=pkg_dict['name']) redirect(url) # Make sure we don't index this dataset if request.params['save'] not in [ 'go-resource', 'go-metadata' ]: data_dict['state'] = 'draft' # allow the state to be changed context['allow_state_change'] = True data_dict['type'] = package_type context['message'] = data_dict.get('log_message', '') self.__generate_spatial_extra_field(data_dict) pkg_dict = get_action('package_create')(context, data_dict) # Restauramos los grupos asignados al dataset (cuando es un insert) update_package_group_relation(package_name, group_names) if ckan_phase and request.params['save'] != 'save-draft': url = h.url_for(controller='package', action='new_resource', id=pkg_dict['name']) redirect(url) elif request.params['save'] == 'save-draft': url = h.url_for(controller='package', action='read', id=pkg_dict['name']) redirect(url) self._form_save_redirect(pkg_dict['name'], 'new', package_type=package_type) except NotAuthorized: abort(401, _('Unauthorized to read package %s') % '') except NotFound, e: abort(404, _('Dataset not found'))
def new(self, data=None, errors=None, error_summary=None): if data and 'type' in data: package_type = data['type'] else: package_type = self._guess_package_type(True) context = { 'model': model, 'session': model.Session, 'user': c.user or c.author, 'auth_user_obj': c.userobj, 'save': 'save' in request.params } # Package needs to have a organization group in the call to # check_access and also to save it try: check_access('package_create', context) except NotAuthorized: abort(401, _('Unauthorized to create a package')) if context['save'] and not data: return self._save_new(context, package_type=package_type) data = data or clean_dict( dict_fns.unflatten( tuplize_dict( parse_params(request.params, ignore_keys=CACHE_PARAMETERS)))) c.resources_json = h.json.dumps(data.get('resources', [])) # convert tags if not supplied in data if data and not data.get('tag_string'): data['tag_string'] = ', '.join( h.dict_list_reduce(data.get('tags', {}), 'name')) errors = errors or {} error_summary = error_summary or {} # in the phased add dataset we need to know that # we have already completed stage 1 stage = ['active'] if data.get('state', '').startswith('draft'): stage = ['active', 'complete'] # if we are creating from a group then this allows the group to be # set automatically data['group_id'] = request.params.get('group') or \ request.params.get('groups__0__id') form_snippet = self._package_form(package_type=package_type) form_vars = { 'data': data, 'errors': errors, 'error_summary': error_summary, 'action': 'new', 'stage': stage, 'dataset_type': package_type, } c.errors_json = h.json.dumps(errors) self._setup_template_variables(context, {}, package_type=package_type) new_template = self._new_template(package_type) c.form = deprecated_lazy_render( new_template, form_snippet, lambda: render(form_snippet, extra_vars=form_vars), 'use of c.form is deprecated. please see ' 'ckan/templates/package/base_form_page.html for an example ' 'of the new way to include the form snippet') return render(new_template, extra_vars={ 'form_vars': form_vars, 'form_snippet': form_snippet, 'dataset_type': package_type })
id=pkg_dict['name']) redirect(url) elif request.params['save'] == 'save-draft': url = h.url_for(controller='package', action='read', id=pkg_dict['name']) redirect(url) self._form_save_redirect(pkg_dict['name'], 'new', package_type=package_type) except NotAuthorized: abort(401, _('Unauthorized to read package %s') % '') except NotFound, e: abort(404, _('Dataset not found')) except dict_fns.DataError: abort(400, _(u'Integrity Error')) except SearchIndexError, e: try: exc_str = unicode(repr(e.args)) except Exception: # We don't like bare excepts exc_str = unicode(str(e)) abort(500, _(u'Unable to add package to search index.') + exc_str) except ValidationError, e: errors = e.error_dict error_summary = e.error_summary if is_an_update: # we need to get the state of the dataset to show the stage we # are on. pkg_dict = get_action('package_show')(context, data_dict) data_dict['state'] = pkg_dict['state'] return self.edit(data_dict['id'], data_dict, errors,