def create(self, model_obj):
otype = model_obj.type
lang = helpers.getLanguage()
## CREATE GROUP OR ORGANIZATION
if otype == 'group' or otype == 'organization' and lang:
log.info('::::: Persisting localised metadata locale :::::')
lang = helpers.getLanguage()
group = model_dictize.group_dictize(model_obj, {'model': model, 'session': model.Session})
GroupMultilang.persist(group, lang)
def after_update(self, context, resource):
otype = resource.get('type')
lang = helpers.getLanguage()
if otype != 'dataset' and lang:
# r = model.Session.query(model.Resource).filter(model.Resource.id == resource.get('id')).all()
r = model.Resource.get(resource.get('id'))
if r:
r = model_dictize.resource_dictize(r, {
'model': model,
'session': model.Session
})
# MULTILANG - persisting resource localized record in multilang table
# q_results = model.Session.query(ResourceMultilang).filter(ResourceMultilang.resource_id == resource.get('id'), ResourceMultilang.lang == lang).all()
q_results = ResourceMultilang.get_for_resource_id_and_lang(
r.get('id'), lang)
if q_results and q_results.count() > 0:
for result in q_results:
result.text = r.get(result.field)
result.save()
else:
log.info(
'Localised fields are missing in resource_multilang table, persisting ...'
)
ResourceMultilang.persist(r, lang)
def after_create(self, context, resource):
otype = resource.get('type')
lang = helpers.getLanguage()
if otype != 'dataset' and lang:
# MULTILANG - Creating new resource for multilang table
# r = model.Session.query(model.Resource).filter(model.Resource.id == resource.get('id')).all()
r = model.Resource.get(resource.get('id'))
if r:
log.info('Localised fields are missing in resource_multilang table, persisting ...')
ResourceMultilang.persist(resource, lang)
def before_show(self, resource_dict):
lang = helpers.getLanguage()
if lang:
# MULTILANG - Localizing resources dict
# q_results = model.Session.query(ResourceMultilang).filter(ResourceMultilang.resource_id == resource_dict.get('id'), ResourceMultilang.lang == lang).all()
q_results = ResourceMultilang.get_for_resource_id_and_lang(resource_dict.get('id'), lang)
if q_results:
for result in q_results:
resource_dict[result.field] = result.text
return resource_dict
def edit(self, model_obj):
otype = model_obj.type
lang = helpers.getLanguage()
## EDIT GROUP OR ORGANIZATION
if otype == 'group' or otype == 'organization' and lang:
group = model_dictize.group_dictize(model_obj, {
'model': model,
'session': model.Session
})
# q_results = model.Session.query(GroupMultilang).filter(GroupMultilang.group_id == group.get('id')).all()
q_results = GroupMultilang.get_for_group_id(group.get('id'))
create_new = False
if q_results:
available_db_lang = []
for result in q_results:
if result.lang not in available_db_lang:
available_db_lang.append(result.lang)
# check if the group identifier name has been changed
if result.name != group.get('name'):
result.name = group.get('name')
result.save()
if lang not in available_db_lang:
create_new = True
else:
for result in q_results:
if result.lang == lang:
result.text = group.get(result.field)
result.save()
else:
create_new = True
if create_new == True:
log.info(
':::::::::::: Localized fields are missing in package_multilang table, persisting defaults using values in the table group :::::::::::::::'
)
GroupMultilang.persist(group, lang)
def after_search(self, search_results, search_params):
search_facets = search_results.get('search_facets')
lang = helpers.getLanguage()
if search_facets and lang:
if 'tags' in search_facets:
# MULTILANG - Localizing Tags display names in Facet list
tags = search_facets.get('tags')
for tag in tags.get('items'):
localized_tag = TagMultilang.by_name(tag.get('name'), lang)
if localized_tag:
tag['display_name'] = localized_tag.text
if 'organization' in search_facets:
# MULTILANG - Localizing Organizations display names in Facet list
organizations = search_facets.get('organization')
for org in organizations.get('items'):
# q_results = model.Session.query(GroupMultilang).filter(GroupMultilang.name == org.get('name'), GroupMultilang.lang == lang).all()
q_results = GroupMultilang.get_for_group_name_and_lang(
org.get('name'), lang)
if q_results:
for result in q_results:
if result.field == 'title':
org['display_name'] = result.text
if 'groups' in search_facets:
# MULTILANG - Localizing Groups display names in Facet list
groups = search_facets.get('groups')
for group in groups.get('items'):
# q_results = model.Session.query(GroupMultilang).filter(GroupMultilang.name == group.get('name'), GroupMultilang.lang == lang).all()
q_results = GroupMultilang.get_for_group_name_and_lang(
group.get('name'), lang)
if q_results:
for result in q_results:
if result.field == 'title':
group['display_name'] = result.text
search_results['search_facets'] = search_facets
return search_results
def recent_updates(n):
#
# Return a list of the n most recently updated datasets.
#
log.debug('::::: Retrieving latest datasets: %r' % n)
context = {
'model': model,
'session': model.Session,
'user': p.toolkit.c.user or p.toolkit.c.author
}
data_dict = {
'rows': n,
'sort': u'metadata_modified desc',
'facet': u'false'
}
try:
search_results = logic.get_action('package_search')(context, data_dict)
except search.SearchError as e:
log.error('Error searching for recently updated datasets')
log.error(e)
search_results = {}
for item in search_results.get('results'):
log.info(
':::::::::::: Retrieving the corresponding localized title and abstract :::::::::::::::'
)
lang = multilang_helpers.getLanguage()
q_results = model.Session.query(PackageMultilang)\
.filter(PackageMultilang.package_id == item.get('id'),
PackageMultilang.lang == lang).all()
if q_results:
for result in q_results:
item[result.field] = result.text
return search_results.get('results', [])
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'])
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', '')
# MULTILANG - retrieving dict for localized tag's strings
extra_tag = None
if data_dict.get('extra_tag'):
extra_tag = data_dict.get('extra_tag')
# After saving in memory the extra_tag dict this must be removed because not present in the schema
del data_dict['extra_tag']
pkg_dict = get_action('package_create')(context, data_dict)
lang = helpers.getLanguage()
# MULTILANG - persisting tags
self.localized_tags_persist(extra_tag, pkg_dict, lang)
# MULTILANG - persisting the localized package dict
log.info('::::: Persisting localised metadata locale :::::')
for field in self.pkg_localized_fields:
if pkg_dict.get(field):
PackageMultilang.persist(
{
'id': pkg_dict.get('id'),
'field': field,
'text': pkg_dict.get(field)
}, lang)
if ckan_phase:
# redirect to add dataset resources
url = h.url_for(controller='package',
action='new_resource',
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))))
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
# MULTILANG - retrieving dict for localized tag's strings
extra_tag = None
if data_dict.get('extra_tag'):
extra_tag = data_dict.get('extra_tag')
# After saving in memory the extra_tag dict this must be removed because not present in the schema
del data_dict['extra_tag']
pkg = get_action('package_update')(context, data_dict)
c.pkg = context['package']
c.pkg_dict = pkg
lang = helpers.getLanguage()
# MULTILANG - persisting tags
self.localized_tags_persist(extra_tag, c.pkg_dict, lang)
# MULTILANG - persisting package dict
log.info(
':::::::::::: Saving the corresponding localized title and abstract :::::::::::::::'
)
# q_results = model.Session.query(PackageMultilang).filter(PackageMultilang.package_id == c.pkg_dict.get('id'), PackageMultilang.lang == lang).all()
q_results = PackageMultilang.get_for_package_id_and_lang(
c.pkg_dict.get('id'), lang)
if q_results:
pkg_processed_field = []
for result in q_results:
# do not update multilang field if original pkg dict doesn't
# have this field anymore. otherwise IntegrityError will raise
# because text will be None
if c.pkg_dict.has_key(result.field):
pkg_processed_field.append(result.field)
log.debug('::::::::::::::: value before %r',
result.text)
result.text = c.pkg_dict.get(result.field)
log.debug('::::::::::::::: value after %r',
result.text)
result.save()
# Check for missing localized fields in DB
for field in self.pkg_localized_fields:
if field not in pkg_processed_field:
if c.pkg_dict.get(field):
PackageMultilang.persist(
{
'id': c.pkg_dict.get('id'),
'field': field,
'text': c.pkg_dict.get(field)
}, lang)
else:
log.info(
':::::::::::: Localised fields are missing in package_multilang table, persisting defaults using values in the table package :::::::::::::::'
)
for field in self.pkg_localized_fields:
if c.pkg_dict.get(field):
PackageMultilang.persist(
{
'id': c.pkg_dict.get('id'),
'field': field,
'text': c.pkg_dict.get(field)
}, lang)
self._form_save_redirect(pkg['name'],
'edit',
package_type=package_type)
except NotAuthorized:
abort(401, _('Unauthorized to read package %s') % id)
except NotFound, e:
abort(404, _('Dataset not found'))
def before_view(self, odict):
otype = odict.get('type')
lang = helpers.getLanguage()
if lang:
if otype == 'group' or otype == 'organization':
# MULTILANG - Localizing Group/Organizzation names and descriptions in search list
# q_results = model.Session.query(GroupMultilang).filter(GroupMultilang.group_id == odict.get('id'), GroupMultilang.lang == lang).all()
q_results = GroupMultilang.get_for_group_id_and_lang(
odict.get('id'), lang)
if q_results:
for result in q_results:
odict[result.field] = result.text
if result.field == 'title':
odict['display_name'] = result.text
elif otype == 'dataset':
# MULTILANG - Localizing Datasets names and descriptions in search list
# MULTILANG - Localizing Tags display names in Facet list
tags = odict.get('tags')
if tags:
for tag in tags:
localized_tag = TagMultilang.by_tag_id(
tag.get('id'), lang)
if localized_tag:
tag['display_name'] = localized_tag.text
# MULTILANG - Localizing package sub dict for the dataset read page
# q_results = model.Session.query(PackageMultilang).filter(PackageMultilang.package_id == odict['id'], PackageMultilang.lang == lang).all()
q_results = PackageMultilang.get_for_package_id_and_lang(
odict.get('id'), lang)
if q_results:
for result in q_results:
if odict.get(result.field, None):
odict[result.field] = result.text
else:
extras = odict.get('extras', None)
if extras and len(extras) > 0:
for extra in extras:
extra_key = extra.get('key', None)
if extra_key and extra_key == result.field:
extra['value'] = result.text
#if result.field == 'notes':
# odict['notes'] = result.text
# MULTILANG - Localizing organization sub dict for the dataset read page
organization = odict.get('organization')
if organization:
# q_results = model.Session.query(GroupMultilang).filter(GroupMultilang.group_id == organization.get('id'), GroupMultilang.lang == lang).all()
q_results = GroupMultilang.get_for_group_id_and_lang(
organization.get('id'), lang)
if q_results:
for result in q_results:
organization[result.field] = result.text
odict['organization'] = organization
# MULTILANG - Localizing resources dict
resources = odict.get('resources')
if resources:
for resource in resources:
# q_results = model.Session.query(ResourceMultilang).filter(ResourceMultilang.resource_id == resource.get('id'), ResourceMultilang.lang == lang).all()
q_results = ResourceMultilang.get_for_resource_id_and_lang(
resource.get('id'), lang)
if q_results:
for result in q_results:
resource[result.field] = result.text
return odict
def _group_or_org_list(context, data_dict, is_org=False):
model = context['model']
api = context.get('api_version')
groups = data_dict.get('groups')
group_type = data_dict.get('type', 'group')
ref_group_by = 'id' if api == 2 else 'name'
pagination_dict = {}
limit = data_dict.get('limit')
if limit:
pagination_dict['limit'] = data_dict['limit']
offset = data_dict.get('offset')
if offset:
pagination_dict['offset'] = data_dict['offset']
if pagination_dict:
pagination_dict, errors = _validate(
data_dict, logic.schema.default_pagination_schema(), context)
if errors:
raise ValidationError(errors)
sort = data_dict.get('sort') or 'name'
q = data_dict.get('q')
# order_by deprecated in ckan 1.8
# if it is supplied and sort isn't use order_by and raise a warning
order_by = data_dict.get('order_by', '')
if order_by:
log.warn('`order_by` deprecated please use `sort`')
if not data_dict.get('sort'):
sort = order_by
# if the sort is packages and no sort direction is supplied we want to do a
# reverse sort to maintain compatibility.
if sort.strip() in ('packages', 'package_count'):
sort = 'package_count desc'
sort_info = _unpick_search(
sort,
allowed_fields=['name', 'packages', 'package_count', 'title'],
total=1)
all_fields = data_dict.get('all_fields', None)
include_extras = all_fields and \
asbool(data_dict.get('include_extras', False))
query = model.Session.query(model.Group)
if include_extras:
# this does an eager load of the extras, avoiding an sql query every
# time group_list_dictize accesses a group's extra.
query = query.options(sqlalchemy.orm.joinedload(model.Group._extras))
query = query.filter(model.Group.state == 'active')
if groups:
query = query.filter(model.Group.name.in_(groups))
if q:
q = u'%{0}%'.format(q)
## MULTILANG FRAGMENT
lang = helpers.getLanguage()
groups_multilang_id_list = []
q_results = model.Session.query(GroupMultilang).filter(
GroupMultilang.lang.ilike(lang),
GroupMultilang.text.ilike(q)).all()
if q_results:
for result in q_results:
log.info(":::::::::::::: Group ID Found:::: %r",
result.group_id)
groups_multilang_id_list.append(result.group_id)
groups_multilang_id_list = set(groups_multilang_id_list)
if len(groups_multilang_id_list) > 0:
#query = query.filter(model.Group.id.in_(groups_multilang_id_list))
query = query.filter(
_or_(model.Group.name.ilike(q), model.Group.title.ilike(q),
model.Group.description.ilike(q),
model.Group.id.in_(groups_multilang_id_list)))
else:
query = query.filter(
_or_(model.Group.name.ilike(q), model.Group.title.ilike(q),
model.Group.description.ilike(q)))
## END OF MULTILANG FRAGMENT
query = query.filter(model.Group.is_organization == is_org)
if not is_org:
query = query.filter(model.Group.type == group_type)
if sort_info:
sort_field = sort_info[0][0]
sort_direction = sort_info[0][1]
if sort_field == 'package_count':
query = query.group_by(model.Group.id, model.Group.name)
sort_model_field = sqlalchemy.func.count(model.Group.id)
elif sort_field == 'name':
sort_model_field = model.Group.name
elif sort_field == 'title':
sort_model_field = model.Group.title
if sort_direction == 'asc':
query = query.order_by(sqlalchemy.asc(sort_model_field))
else:
query = query.order_by(sqlalchemy.desc(sort_model_field))
if limit:
query = query.limit(limit)
if offset:
query = query.offset(offset)
groups = query.all()
if all_fields:
action = 'organization_show' if is_org else 'group_show'
group_list = []
for group in groups:
data_dict['id'] = group.id
for key in ('include_extras', 'include_tags', 'include_users',
'include_groups', 'include_followers'):
if key not in data_dict:
data_dict[key] = False
group_list.append(logic.get_action(action)(context, data_dict))
else:
group_list = [getattr(group, ref_group_by) for group in groups]
return group_list