def group_list(context, data_dict):
"""Returns a list of groups"""
model = context["model"]
user = context["user"]
api = context.get("api_version") or "1"
ref_group_by = "id" if api == "2" else "name"
order_by = data_dict.get("order_by", "name")
if order_by not in set(("name", "packages")):
raise ValidationError('"order_by" value %r not implemented.' % order_by)
all_fields = data_dict.get("all_fields", None)
check_access("group_list", context, data_dict)
query = model.Session.query(model.Group).join(model.GroupRevision)
query = query.filter(model.GroupRevision.state == "active")
query = query.filter(model.GroupRevision.current == True)
if order_by == "name":
sort_by, reverse = "name", False
groups = query.all()
if order_by == "packages":
sort_by, reverse = "packages", True
if not all_fields:
group_list = [getattr(p, ref_group_by) for p in groups]
else:
group_list = group_list_dictize(groups, context, lambda x: x[sort_by], reverse)
return group_list
def group_list(context, data_dict):
'''Returns a list of groups'''
model = context['model']
user = context['user']
api = context.get('api_version') or '1'
ref_group_by = 'id' if api == '2' else 'name'
order_by = data_dict.get('order_by', 'name')
if order_by not in set(('name', 'packages')):
raise ValidationError('"order_by" value %r not implemented.' %
order_by)
all_fields = data_dict.get('all_fields', None)
check_access('group_list', context, data_dict)
query = model.Session.query(model.Group).join(model.GroupRevision)
query = query.filter(model.GroupRevision.state == 'active')
query = query.filter(model.GroupRevision.current == True)
if order_by == 'name':
sort_by, reverse = 'name', False
groups = query.all()
if order_by == 'packages':
sort_by, reverse = 'packages', True
group_list = group_list_dictize(groups, context, lambda x: x[sort_by],
reverse)
if not all_fields:
group_list = [group[ref_group_by] for group in group_list]
return group_list
def groups(self, id):
q = (
model.Session.query(model.Group)
.filter(model.Group.is_organization == False)
.filter(model.Group.state == "active")
)
groups = q.all()
"""
package = c.get('package')
if package:
groups = set(groups) - set(package.get_groups())
"""
context = {
"model": model,
"session": model.Session,
"user": c.user or c.author,
"for_view": True,
"auth_user_obj": c.userobj,
"use_cache": False,
}
group_list = model_dictize.group_list_dictize(groups, context)
c.event_dropdown = [[group["id"], group["display_name"]] for group in group_list]
return super(MapactionPackageController, self).groups(id)
def metadata_collection_dictize(metadata_collection, context):
model = context['model']
is_latest_revision = not (context.get('revision_id')
or context.get('revision_date'))
execute = _execute if is_latest_revision else _execute_with_revision
result_dict = ckan_model_dictize.group_dictize(
metadata_collection,
context,
include_groups=False,
include_tags=False,
include_users=False,
include_extras=True,
packages_field='dataset_count')
# infrastructures
if is_latest_revision:
member = model.member_table
else:
member = model.member_revision_table
group = model.group_table
q = select([group, member.c.capacity],
from_obj=member.join(group, group.c.id == member.c.group_id)
).where(member.c.table_id == metadata_collection.id)\
.where(member.c.state == 'active') \
.where(group.c.is_organization == False) \
.where(group.c.type == 'infrastructure')
result = execute(q, member, context)
context['with_capacity'] = False
result_dict['infrastructures'] = ckan_model_dictize.group_list_dictize(
result, context, with_package_counts=False)
return result_dict
def organization_list_without_memberships(context, data_dict):
model = context['model']
if data_dict.get('id'):
user_obj = model.User.get(data_dict['id'])
if not user_obj:
raise NotFound
user = user_obj.name
else:
user = context['user']
logic.check_access('organization_list_without_memberships', context, data_dict)
user_id = authz.get_user_id_for_username(user, allow_none=True)
if not user_id:
return []
subquery = model.Session.query(model.Group.id)\
.filter(model.Member.table_name == 'user')\
.filter(model.Member.table_id == user_id)\
.filter(model.Group.id == model.Member.group_id)\
.filter(model.Member.state.in_(['active', 'pending'])) \
.distinct(model.Group.id) \
.filter(model.Group.is_organization == True) # noqa
groups = model.Session.query(model.Group) \
.filter(model.Group.id.notin_(subquery)).all()
return model_dictize.group_list_dictize(groups,
context,
with_package_counts=asbool(data_dict.get('include_dataset_count')))
def group_list_authz(context, data_dict):
"""Return the list of groups that the user is authorized to edit. Replaces
the core authz method of the same name."""
user = context["user"]
model = context["model"]
user_id = authz.get_user_id_for_username(user, allow_none=True)
toolkit.check_access("group_list_authz", context, data_dict)
if GroupAdmin.is_user_group_admin(model.Session, user_id):
q = (
model.Session.query(model.Group)
.filter(model.Group.is_organization == False)
.filter(model.Group.state == "active")
)
groups = q.all()
group_list = model_dictize.group_list_dictize(groups, context)
return group_list
else:
# defer to core method
return core_group_list_authz(context, data_dict)
def group_list(context, data_dict):
'''Returns a list of groups'''
model = context['model']
user = context['user']
api = context.get('api_version') or '1'
ref_group_by = 'id' if api == '2' else 'name';
order_by = data_dict.get('order_by', 'name')
if order_by not in set(('name', 'packages')):
raise ValidationError('"order_by" value %r not implemented.' % order_by)
all_fields = data_dict.get('all_fields',None)
check_access('group_list',context, data_dict)
query = model.Session.query(model.Group).join(model.GroupRevision)
query = query.filter(model.GroupRevision.state=='active')
query = query.filter(model.GroupRevision.current==True)
if order_by == 'name':
sort_by, reverse = 'name', False
groups = query.all()
if order_by == 'packages':
sort_by, reverse = 'packages', True
group_list = group_list_dictize(groups, context,
lambda x:x[sort_by], reverse)
if not all_fields:
group_list = [group[ref_group_by] for group in group_list]
return group_list
def group_list_authz(context, data_dict):
try:
check_access('member_create', context, data_dict)
except:
return []
available_only = data_dict.get('available_only', False)
glist = set([(g['id'], g['display_name'])
for g in ckan_action.get.group_list_authz(context, data_dict)
])
for t in ['topic', 'product', 'lad', 'accesslevel']:
glist |= set([(g['id'], g['display_name'])
for g in group_list(context, {
'type': t,
'all_fields': True
})])
if available_only:
package = context.get('package')
if package:
glist -= set([(g['id'], g['display_name'])
for g in model_dictize.group_list_dictize(
package.get_groups(), context)])
return [{
'id': g[0],
'display_name': g[1]
} for g in sorted(list(glist), key=lambda g: g[1].lower())]
def logged_in(self):
# we need to set the language via a redirect
lang = session.pop('lang', None)
session.save()
# we need to set the language explicitly here or the flash
# messages will not be translated.
i18n.set_lang(lang)
if c.user:
is_new = False
is_sysadmin = new_authz.is_sysadmin(c.user)
# Retrieve information about the current user
context = {'model': model, 'session': model.Session,
'user': c.user or c.author,
'schema': schema.user_new_form_schema()}
data_dict = {'id': c.user}
user_dict = get_action('user_show')(context, data_dict)
# This check is not needed (or correct) for sys admins
if not is_sysadmin:
# Get all organizations and all groups the user belongs to
orgs_q = model.Session.query(model.Group) \
.filter(model.Group.is_organization == True) \
.filter(model.Group.state == 'active')
q = model.Session.query(model.Member) \
.filter(model.Member.table_name == 'user') \
.filter(model.Member.table_id == user_dict['id'])
group_ids = []
for row in q.all():
group_ids.append(row.group_id)
if not group_ids:
is_new = True
else:
orgs_q = orgs_q.filter(model.Group.id.in_(group_ids))
orgs_list = model_dictize.group_list_dictize(orgs_q.all(), context)
if len(orgs_list) == 0:
is_new = True
h.flash_success(_("<p><strong>Note</strong></p>"
"<p>%s is now logged in</p>") %
user_dict['display_name'], allow_html=True)
if is_new:
return h.redirect_to(controller='ckanext.canada.controller:CanadaController',
action='view_new_user', locale=lang)
else:
return h.redirect_to(controller='package',
action='search', locale=lang)
else:
h.flash_error(_('Login failed. Bad username or password.'))
return h.redirect_to(controller='user',
action='login', locale=lang)
def organization_list_without_memberships(context, data_dict):
model = context['model']
if data_dict.get('id'):
user_obj = model.User.get(data_dict['id'])
if not user_obj:
raise NotFound
user = user_obj.name
else:
user = context['user']
logic.check_access('organization_list_without_memberships', context, data_dict)
user_id = authz.get_user_id_for_username(user, allow_none=True)
if not user_id:
return []
subquery = model.Session.query(model.Group.id)\
.filter(model.Member.table_name == 'user')\
.filter(model.Member.table_id == user_id)\
.filter(model.Group.id == model.Member.group_id)\
.filter(model.Member.state.in_(['active', 'pending'])) \
.distinct(model.Group.id) \
.filter(model.Group.is_organization == True) # noqa
groups = model.Session.query(model.Group) \
.filter(model.Group.id.notin_(subquery)).all()
return model_dictize.group_list_dictize(groups,
context,
with_package_counts=asbool(data_dict.get('include_dataset_count')))
def group_list(context, data_dict):
'''Returns a list of groups'''
model = context['model']
user = context['user']
api = context.get('api_version') or '1'
ref_group_by = 'id' if api == '2' else 'name';
order_by = data_dict.get('order_by', 'name')
if order_by not in set(('name', 'packages')):
raise ValidationError('"order_by" value %r not implemented.' % order_by)
all_fields = data_dict.get('all_fields',None)
check_access('group_list',context, data_dict)
query = model.Session.query(model.Group).join(model.GroupRevision)
query = query.filter(model.GroupRevision.state=='active')
query = query.filter(model.GroupRevision.current==True)
if order_by == 'name':
query = query.order_by(model.Group.name.asc())
query = query.order_by(model.Group.title.asc())
groups = query.all()
if order_by == 'packages':
groups = sorted(query.all(),
key=lambda g: len(g.packages),
reverse=True)
if not all_fields:
group_list = [getattr(p, ref_group_by) for p in groups]
else:
group_list = group_list_dictize(groups,context)
return group_list
def test_group_list_dictize_sort_by_package_count(self):
group1 = factories.Group()
group2 = factories.Group()
factories.Dataset(groups=[{
"name": group1["name"]
}, {
"name": group2["name"]
}])
factories.Dataset(groups=[{"name": group2["name"]}])
group_list = [
model.Group.get(group2["name"]),
model.Group.get(group1["name"])
]
context = {"model": model, "session": model.Session}
group_dicts = model_dictize.group_list_dictize(
group_list,
context,
sort_key=lambda x: x["package_count"],
with_package_counts=True,
)
# list is resorted by package counts
assert group_dicts[0]["name"] == group1["name"]
assert group_dicts[1]["name"] == group2["name"]
def group_list_authz(context, data_dict):
'''Return the list of groups that the user is authorized to edit.
:param available_only: remove the existing groups in the package
(optional, default: ``False``)
:type available_only: boolean
:param am_member: if ``True`` return only the groups the logged-in user is
a member of, otherwise return all groups that the user is authorized to
edit (for example, sysadmin users are authorized to edit all groups)
(optional, default: ``False``)
:type am-member: boolean
:returns: list of dictized groups that the user is authorized to edit
:rtype: list of dicts
'''
model = context['model']
user = context['user']
available_only = data_dict.get('available_only', False)
am_member = data_dict.get('am_member', False)
group_type = data_dict.get('type', 'group')
_check_access('group_list_authz', context, data_dict)
sysadmin = authz.is_sysadmin(user)
roles = authz.get_roles_with_permission('manage_group')
if not roles:
return []
user_id = authz.get_user_id_for_username(user, allow_none=True)
if not user_id:
return []
if not sysadmin or am_member:
q = model.Session.query(model.Member) \
.filter(model.Member.table_name == 'user') \
.filter(model.Member.capacity.in_(roles)) \
.filter(model.Member.table_id == user_id) \
.filter(model.Member.state == 'active')
group_ids = []
for row in q.all():
group_ids.append(row.group_id)
if not group_ids:
return []
q = model.Session.query(model.Group) \
.filter(model.Group.is_organization == False) \
.filter(model.Group.state == 'active') \
.filter(model.Group.type == group_type)
if not sysadmin or am_member:
q = q.filter(model.Group.id.in_(group_ids))
groups = q.all()
if available_only:
package = context.get('package')
if package:
groups = set(groups) - set(package.get_groups())
group_list = model_dictize.group_list_dictize(groups, context)
return group_list
def organization_list_for_user(context, data_dict):
perm = data_dict.get('permission')
if perm in ['create_dataset', 'update_dataset', 'delete_dataset']:
# Create a copy of the data dict, and change the request permission to
# 'read' which will be granted to all members of a group.
data_dict = dict(data_dict.items() + {'permission': 'read'}.items())
#return fb(context, data_dict)
#return core_org_list_for_user(context, data_dict)
'''Return the list of organizations that the user is a member of.
:param permission: the permission the user has against the returned organizations
(optional, default: ``edit_group``)
:type permission: string
:returns: list of dictized organizations that the user is authorized to edit
:rtype: list of dicts
'''
model = context['model']
user = context['user']
_check_access('organization_list_for_user', context, data_dict)
sysadmin = new_authz.is_sysadmin(user)
orgs_q = model.Session.query(model.Group) \
.filter(model.Group.is_organization == True) \
.filter(model.Group.state == 'active')
if not sysadmin:
# for non-Sysadmins check they have the required permission
permission = data_dict.get('permission', 'edit_group')
roles = ckan.new_authz.get_roles_with_permission(permission)
if not roles:
return []
user_id = new_authz.get_user_id_for_username(user, allow_none=True)
if not user_id:
return []
q = model.Session.query(model.Member) \
.filter(model.Member.table_name == 'user') \
.filter(model.Member.capacity.in_(roles)) \
.filter(model.Member.table_id == user_id)
group_ids = []
for row in q.all():
group_ids.append(row.group_id)
if not group_ids:
return []
orgs_q = orgs_q.filter(model.Group.id.in_(group_ids))
orgs_list = model_dictize.group_list_dictize(orgs_q.all(), context)
return orgs_list
def test_group_list_dictize_including_extras(self):
factories.Group(extras=[{'key': 'k1', 'value': 'v1'}])
group_list = model.Session.query(model.Group).filter_by().all()
context = {'model': model, 'session': model.Session}
group_dicts = model_dictize.group_list_dictize(group_list, context,
include_extras=True)
assert_equal(group_dicts[0]['extras'][0]['key'], 'k1')
def test_group_list_dictize_including_extras(self):
factories.Group(extras=[{'key': 'k1', 'value': 'v1'}])
group_list = model.Session.query(model.Group).filter_by().all()
context = {'model': model, 'session': model.Session}
group_dicts = model_dictize.group_list_dictize(group_list, context,
include_extras=True)
assert_equal(group_dicts[0]['extras'][0]['key'], 'k1')
def organization_list(context, data_dict):
""" Modified from ckan.logic.action.get._group_or_org_list.
Sort by title instead of name and lower case ordering.
"""
model = context['model']
api = context.get('api_version')
groups = data_dict.get('groups')
ref_group_by = 'id' if api == 2 else 'name'
sort = data_dict.get('sort', 'title')
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() == 'packages':
sort = 'packages desc'
sort_info = ckan.logic.action.get._unpick_search(sort,
allowed_fields=['name', 'packages', 'title'],
total=1)
all_fields = data_dict.get('all_fields', None)
query = model.Session.query(model.Group).join(model.GroupRevision)
query = query.filter(model.GroupRevision.state=='active')
query = query.filter(model.GroupRevision.current==True)
if groups:
query = query.filter(model.GroupRevision.name.in_(groups))
if q:
q = u'%{0}%'.format(q)
query = query.filter(_or_(
model.GroupRevision.name.ilike(q),
model.GroupRevision.title.ilike(q),
model.GroupRevision.description.ilike(q),
))
query = query.filter(model.GroupRevision.is_organization==True)
groups = query.all()
group_list = model_dictize.group_list_dictize(groups, context,
lambda x:x[sort_info[0][0]].lower(),
sort_info[0][1] == 'desc')
if not all_fields:
group_list = [group[ref_group_by] for group in group_list]
return group_list
def test_group_list_dictize_including_extras(self):
group = factories.Group.model(extras=[{"key": "k1", "value": "v1"}])
context = {"model": model, "session": model.Session}
group_dicts = model_dictize.group_list_dictize(
[group], context, include_extras=True
)
assert group_dicts[0]["extras"][0]["key"] == "k1"
def organization_list_for_user(context, data_dict):
'''Return the organizations that the user has a given permission for.
By default this returns the list of organizations that the currently
authorized user can edit, i.e. the list of organizations that the user is an
admin of.
Specifically it returns the list of organizations that the currently
authorized user has a given permission (for example: "edit_group") against.
When a user becomes a member of an organization in CKAN they're given a
"capacity" (sometimes called a "role"), for example "member", "editor" or
"admin".
Each of these roles has certain permissions associated with it. For example
the admin role has the "admin" permission (which means they have permission
to do anything). The editor role has permissions like "create_dataset",
"update_dataset" and "delete_dataset". The member role has the "read"
permission.
This function returns the list of organizations that the authorized user has
a given permission for. For example the list of organizations that the user
is an admin of, or the list of organizations that the user can create
datasets in.
:param permission: the permission the user has against the
returned organizations, for example ``"read"`` or ``"create_dataset"``
(optional, default: ``"edit_group"``)
:type permission: string
:returns: list of organizations that the user has the given permission for
:rtype: list of dicts
'''
model = context['model']
user = context['user']
logic.check_access('organization_list_for_user', context, data_dict)
sysadmin = new_authz.is_sysadmin(user)
orgs_q = model.Session.query(model.Group) \
.filter(model.Group.is_organization == True) \
.filter(model.Group.state == 'active')
user_roles = user_custom_roles(context, data_dict)
if not sysadmin and not Roles.MOD_R_DATA in user_roles:
# for non-Sysadmins check they have the required permission
permission = data_dict.get('permission', 'edit_group')
roles = new_authz.get_roles_with_permission(permission)
if not roles:
return []
user_id = new_authz.get_user_id_for_username(user, allow_none=True)
if not user_id:
return []
q = model.Session.query(model.Member) \
.filter(model.Member.table_name == 'user') \
.filter(model.Member.capacity.in_(roles)) \
.filter(model.Member.table_id == user_id) \
.filter(model.Member.state == 'active')
group_ids = []
for row in q.all():
group_ids.append(row.group_id)
if not group_ids:
return []
orgs_q = orgs_q.filter(model.Group.id.in_(group_ids))
orgs_list = model_dictize.group_list_dictize(orgs_q.all(), context)
return orgs_list
def organization_list_for_user(context, data_dict):
'''Return the organizations that the user has a given permission for.
By default this returns the list of organizations that the currently
authorized user can edit, i.e. the list of organizations that the user is an
admin of.
Specifically it returns the list of organizations that the currently
authorized user has a given permission (for example: "edit_group") against.
When a user becomes a member of an organization in CKAN they're given a
"capacity" (sometimes called a "role"), for example "member", "editor" or
"admin".
Each of these roles has certain permissions associated with it. For example
the admin role has the "admin" permission (which means they have permission
to do anything). The editor role has permissions like "create_dataset",
"update_dataset" and "delete_dataset". The member role has the "read"
permission.
This function returns the list of organizations that the authorized user has
a given permission for. For example the list of organizations that the user
is an admin of, or the list of organizations that the user can create
datasets in.
:param permission: the permission the user has against the
returned organizations, for example ``"read"`` or ``"create_dataset"``
(optional, default: ``"edit_group"``)
:type permission: string
:returns: list of organizations that the user has the given permission for
:rtype: list of dicts
'''
model = context['model']
user = context['user']
logic.check_access('organization_list_for_user', context, data_dict)
sysadmin = new_authz.is_sysadmin(user)
orgs_q = model.Session.query(model.Group) \
.filter(model.Group.is_organization == True) \
.filter(model.Group.state == 'active')
user_roles = user_custom_roles(context, data_dict)
if not sysadmin and not 'datovy-kurator' in user_roles:
# for non-Sysadmins check they have the required permission
permission = data_dict.get('permission', 'edit_group')
roles = new_authz.get_roles_with_permission(permission)
if not roles:
return []
user_id = new_authz.get_user_id_for_username(user, allow_none=True)
if not user_id:
return []
q = model.Session.query(model.Member) \
.filter(model.Member.table_name == 'user') \
.filter(model.Member.capacity.in_(roles)) \
.filter(model.Member.table_id == user_id) \
.filter(model.Member.state == 'active')
group_ids = []
for row in q.all():
group_ids.append(row.group_id)
if not group_ids:
return []
orgs_q = orgs_q.filter(model.Group.id.in_(group_ids))
orgs_list = model_dictize.group_list_dictize(orgs_q.all(), context)
return orgs_list
def test_group_list_dictize_without_package_count(self):
group_ = factories.Group()
factories.Dataset(groups=[{'name': group_['name']}])
group_list = [model.Group.get(group_['name'])]
context = {'model': model, 'session': model.Session}
group_dicts = model_dictize.group_list_dictize(
group_list, context, with_package_counts=False)
assert 'packages' not in group_dicts[0]
def test_group_list_dictize_without_package_count(self):
group_ = factories.Group()
factories.Dataset(groups=[{"name": group_["name"]}])
group_list = [model.Group.get(group_["name"])]
context = {"model": model, "session": model.Session}
group_dicts = model_dictize.group_list_dictize(
group_list, context, with_package_counts=False)
assert "packages" not in group_dicts[0]
def test_group_list_dictize_without_package_count(self):
group_ = factories.Group()
factories.Dataset(groups=[{'name': group_['name']}])
group_list = [model.Group.get(group_['name'])]
context = {'model': model, 'session': model.Session}
group_dicts = model_dictize.group_list_dictize(
group_list, context, with_package_counts=False)
assert 'packages' not in group_dicts[0]
def test_group_list_dictize_including_extras(self):
factories.Group(extras=[{"key": "k1", "value": "v1"}])
group_list = model.Session.query(model.Group).filter_by().all()
context = {"model": model, "session": model.Session}
group_dicts = model_dictize.group_list_dictize(group_list,
context,
include_extras=True)
assert group_dicts[0]["extras"][0]["key"] == "k1"
def dge_dataset_form_organization_list():
"""
Get a list of all active organizations
"""
context = {'model': model}
orgs_q = model.Session.query(model.Group) \
.filter(model.Group.is_organization == True) \
.filter(model.Group.state == 'active')
orgs_list = model_dictize.group_list_dictize(orgs_q.all(), context)
return orgs_list
def test_group_list_dictize_sorted(self):
factories.Group(name='aa')
factories.Group(name='bb')
group_list = [model.Group.get(u'bb'), model.Group.get(u'aa')]
context = {'model': model, 'session': model.Session}
group_dicts = model_dictize.group_list_dictize(group_list, context)
# list is resorted by name
assert_equal(group_dicts[0]['name'], 'aa')
assert_equal(group_dicts[1]['name'], 'bb')
def test_group_list_dictize_sorted(self):
factories.Group(name="aa")
factories.Group(name="bb")
group_list = [model.Group.get(u"bb"), model.Group.get(u"aa")]
context = {"model": model, "session": model.Session}
group_dicts = model_dictize.group_list_dictize(group_list, context)
# list is resorted by name
assert group_dicts[0]["name"] == "aa"
assert group_dicts[1]["name"] == "bb"
def test_group_list_dictize_reverse_sorted(self):
factories.Group(name='aa')
factories.Group(name='bb')
group_list = [model.Group.get(u'aa'),
model.Group.get(u'bb')]
context = {'model': model, 'session': model.Session}
group_dicts = model_dictize.group_list_dictize(group_list, context,
reverse=True)
assert_equal(group_dicts[0]['name'], 'bb')
assert_equal(group_dicts[1]['name'], 'aa')
def test_group_list_dictize(self):
group = factories.Group.model()
context = {"model": model, "session": model.Session}
group_dicts = model_dictize.group_list_dictize([group], context)
assert len(group_dicts) == 1
assert group_dicts[0]["name"] == group.name
assert group_dicts[0]["package_count"] == 0
assert "extras" not in group_dicts[0]
assert "tags" not in group_dicts[0]
assert "groups" not in group_dicts[0]
def test_group_list_dictize(self):
group = factories.Group()
group_list = model.Session.query(model.Group).filter_by().all()
context = {"model": model, "session": model.Session}
group_dicts = model_dictize.group_list_dictize(group_list, context)
assert len(group_dicts) == 1
assert group_dicts[0]["name"] == group["name"]
assert group_dicts[0]["package_count"] == 0
assert "extras" not in group_dicts[0]
assert "tags" not in group_dicts[0]
assert "groups" not in group_dicts[0]
def test_group_list_dictize_including_groups(self):
factories.Group(name='parent')
factories.Group(name='child', groups=[{'name': 'parent'}])
group_list = [model.Group.get(u'parent'), model.Group.get(u'child')]
context = {'model': model, 'session': model.Session}
child_dict, parent_dict = model_dictize.group_list_dictize(
group_list, context, include_groups=True)
assert_equal(parent_dict['name'], 'parent')
assert_equal(child_dict['name'], 'child')
assert_equal(parent_dict['groups'], [])
assert_equal(child_dict['groups'][0]['name'], 'parent')
def test_group_list_dictize(self):
group = factories.Group()
group_list = model.Session.query(model.Group).filter_by().all()
context = {'model': model, 'session': model.Session}
group_dicts = model_dictize.group_list_dictize(group_list, context)
assert_equal(len(group_dicts), 1)
assert_equal(group_dicts[0]['name'], group['name'])
assert_equal(group_dicts[0]['packages'], 0)
assert 'extras' not in group_dicts[0]
assert 'tags' not in group_dicts[0]
assert 'groups' not in group_dicts[0]
def test_group_list_dictize_sorted(self):
# we need to set the title because group_list_dictze by default sorts
# them per display_name
group1 = factories.Group(title="aa")
group2 = factories.Group(title="bb")
group_list = [model.Group.get(group2["name"]), model.Group.get(group1["name"])]
context = {"model": model, "session": model.Session}
group_dicts = model_dictize.group_list_dictize(group_list, context)
# list is resorted by name
assert group_dicts[0]["name"] == group1["name"]
assert group_dicts[1]["name"] == group2["name"]
def test_group_list_dictize_including_tags(self):
group = factories.Group.model()
tag = factories.Tag.model()
member = model.Member(group=group, table_id=tag.id, table_name="tag")
model.Session.add(member)
model.Session.commit()
context = {"model": model, "session": model.Session}
group_dicts = model_dictize.group_list_dictize([group],
context,
include_tags=True)
assert group_dicts[0]["tags"][0]["name"] == tag.name
def test_group_list_dictize_including_groups(self):
factories.Group(name="parent")
factories.Group(name="child", groups=[{"name": "parent"}])
group_list = [model.Group.get(u"parent"), model.Group.get(u"child")]
context = {"model": model, "session": model.Session}
child_dict, parent_dict = model_dictize.group_list_dictize(
group_list, context, include_groups=True)
assert parent_dict["name"] == "parent"
assert child_dict["name"] == "child"
assert parent_dict["groups"] == []
assert child_dict["groups"][0]["name"] == "parent"
def test_group_list_dictize_including_groups(self):
factories.Group(name='parent')
factories.Group(name='child', groups=[{'name': 'parent'}])
group_list = [model.Group.get(u'parent'), model.Group.get(u'child')]
context = {'model': model, 'session': model.Session}
child_dict, parent_dict = model_dictize.group_list_dictize(
group_list, context, include_groups=True)
assert_equal(parent_dict['name'], 'parent')
assert_equal(child_dict['name'], 'child')
assert_equal(parent_dict['groups'], [])
assert_equal(child_dict['groups'][0]['name'], 'parent')
def test_group_list_dictize(self):
group = factories.Group()
group_list = model.Session.query(model.Group).filter_by().all()
context = {'model': model, 'session': model.Session}
group_dicts = model_dictize.group_list_dictize(group_list, context)
assert_equal(len(group_dicts), 1)
assert_equal(group_dicts[0]['name'], group['name'])
assert_equal(group_dicts[0]['packages'], 0)
assert 'extras' not in group_dicts[0]
assert 'tags' not in group_dicts[0]
assert 'groups' not in group_dicts[0]
def test_group_list_dictize_including_groups(self):
parent = factories.Group(title="Parent")
child = factories.Group(title="Child", groups=[{"name": parent["name"]}])
group_list = [model.Group.get(parent["name"]), model.Group.get(child["name"])]
context = {"model": model, "session": model.Session}
child_dict, parent_dict = model_dictize.group_list_dictize(
group_list, context, sort_key=operator.itemgetter("title"),
include_groups=True
)
assert parent_dict["name"] == parent["name"]
assert child_dict["name"] == child["name"]
assert parent_dict["groups"] == []
assert child_dict["groups"][0]["name"] == parent["name"]
def test_group_list_dictize_sort_by_package_count(self):
factories.Group(name='aa')
factories.Group(name='bb')
factories.Dataset(groups=[{'name': 'aa'}, {'name': 'bb'}])
factories.Dataset(groups=[{'name': 'bb'}])
group_list = [model.Group.get(u'bb'),
model.Group.get(u'aa')]
context = {'model': model, 'session': model.Session}
group_dicts = model_dictize.group_list_dictize(
group_list, context, sort_key=lambda x: x['package_count'],
with_package_counts=True)
# list is resorted by package counts
assert_equal(group_dicts[0]['name'], 'aa')
assert_equal(group_dicts[1]['name'], 'bb')
def test_group_list_dictize_sort_by_package_count(self):
factories.Group(name='aa')
factories.Group(name='bb')
factories.Dataset(groups=[{'name': 'aa'}, {'name': 'bb'}])
factories.Dataset(groups=[{'name': 'bb'}])
group_list = [model.Group.get(u'bb'),
model.Group.get(u'aa')]
context = {'model': model, 'session': model.Session}
group_dicts = model_dictize.group_list_dictize(
group_list, context, sort_key=lambda x: x['package_count'],
with_package_counts=True)
# list is resorted by package counts
assert_equal(group_dicts[0]['name'], 'aa')
assert_equal(group_dicts[1]['name'], 'bb')
def organization_list_for_user(ctx, data_dict=None):
user = model.User.get(ctx['user'])
if user is None:
return []
# We have too
logic.check_access('organization_list_for_user', ctx, data_dict)
rel = db.UserOrgRelation.get(user.id)
if rel is None:
# Not a student, revert
return logic.action.get.organization_list_for_user(ctx, data_dict)
org_list = [model.Group.get(rel.org_id)]
pkg_count_flag = tk.asbool(data_dict.get('include_dataset_count', 'false'))
return model_dictize.group_list_dictize(org_list, ctx, with_package_counts=pkg_count_flag)
def get_package_groups(package_id):
context = {
'model': model,
'session': model.Session,
'for_view': True,
'use_cache': False
}
data_dict = {'all_fields': True, 'include_extras': True}
groups = get_action('group_list')(context, data_dict)
group_list = []
try:
pkg_obj = Package.get(package_id)
pkg_group_ids = set(group['id'] for group in group_list_dictize(
pkg_obj.get_groups('group', None), context))
group_list = [
group for group in groups if group['id'] in pkg_group_ids
]
if c.user:
context = {
'model': model,
'session': model.Session,
'user': c.user,
'for_view': True,
'auth_user_obj': c.userobj,
'use_cache': False,
'is_member': True
}
data_dict = {'id': package_id}
users_groups = get_action('group_list_authz')(context, data_dict)
user_group_ids = set(group['id'] for group in users_groups)
for group in group_list:
group['user_member'] = (group['id'] in user_group_ids)
except (NotFound):
abort(404, _('Dataset not found'))
return group_list
def test_group_list_dictize_sort_by_package_count(self):
factories.Group(name="aa")
factories.Group(name="bb")
factories.Dataset(groups=[{"name": "aa"}, {"name": "bb"}])
factories.Dataset(groups=[{"name": "bb"}])
group_list = [model.Group.get(u"bb"), model.Group.get(u"aa")]
context = {"model": model, "session": model.Session}
group_dicts = model_dictize.group_list_dictize(
group_list,
context,
sort_key=lambda x: x["package_count"],
with_package_counts=True,
)
# list is resorted by package counts
assert group_dicts[0]["name"] == "aa"
assert group_dicts[1]["name"] == "bb"
def _service_organizations(self):
''' modified from organization_list_for_user '''
context = {'user': c.user}
data_dict = {'permission': 'create_dataset'}
user = context['user']
toolkit.check_access('organization_list_for_user', context, data_dict)
sysadmin = new_authz.is_sysadmin(user)
orgs_q = model.Session.query(model.Group) \
.filter(model.Group.is_organization == True) \
.filter(model.Group.state == 'active') # noqa
if not sysadmin:
# for non-Sysadmins check they have the required permission
permission = data_dict.get('permission', 'edit_group')
roles = new_authz.get_roles_with_permission(permission)
if not roles:
return []
user_id = new_authz.get_user_id_for_username(user, allow_none=True)
if not user_id:
return []
q = model.Session.query(model.Member) \
.filter(model.Member.table_name == 'user') \
.filter(model.Member.capacity.in_(roles)) \
.filter(model.Member.table_id == user_id) \
.filter(model.Member.state == 'active')
group_ids = []
for row in q.all():
group_ids.append(row.group_id)
if not group_ids:
return []
orgs_q = orgs_q.filter(model.Group.id.in_(group_ids))
orgs_q = orgs_q.join(model.GroupExtra).filter(model.GroupExtra.key == u'public_adminstration_organization') \
.filter(model.GroupExtra.value == u'true') # YTP modification
return model_dictize.group_list_dictize(orgs_q.all(), context)
def _service_organizations(self):
''' modified from organization_list_for_user '''
context = {'user': c.user}
data_dict = {'permission': 'create_dataset'}
user = context['user']
toolkit.check_access('organization_list_for_user', context, data_dict)
sysadmin = authz.is_sysadmin(user)
orgs_q = model.Session.query(model.Group) \
.filter(model.Group.is_organization == True) \
.filter(model.Group.state == 'active') # noqa
if not sysadmin:
# for non-Sysadmins check they have the required permission
permission = data_dict.get('permission', 'edit_group')
roles = authz.get_roles_with_permission(permission)
if not roles:
return []
user_id = authz.get_user_id_for_username(user, allow_none=True)
if not user_id:
return []
q = model.Session.query(model.Member) \
.filter(model.Member.table_name == 'user') \
.filter(model.Member.capacity.in_(roles)) \
.filter(model.Member.table_id == user_id) \
.filter(model.Member.state == 'active')
group_ids = []
for row in q.all():
group_ids.append(row.group_id)
if not group_ids:
return []
orgs_q = orgs_q.filter(model.Group.id.in_(group_ids))
orgs_q = orgs_q.join(model.GroupExtra).filter(model.GroupExtra.key == u'public_adminstration_organization') \
.filter(model.GroupExtra.value == u'true') # YTP modification
return model_dictize.group_list_dictize(orgs_q.all(), context)
def test_group_list_dictize_including_tags(self):
factories.Group()
# group tags aren't in the group_create schema, so its slightly more
# convoluted way to create them
group_obj = model.Session.query(model.Group).first()
tag = model.Tag(name='t1')
model.Session.add(tag)
model.Session.commit()
tag = model.Session.query(model.Tag).first()
group_obj = model.Session.query(model.Group).first()
member = model.Member(group=group_obj, table_id=tag.id,
table_name='tag')
model.Session.add(member)
model.repo.new_revision()
model.Session.commit()
group_list = model.Session.query(model.Group).filter_by().all()
context = {'model': model, 'session': model.Session}
group_dicts = model_dictize.group_list_dictize(group_list, context,
include_tags=True)
assert_equal(group_dicts[0]['tags'][0]['name'], 't1')
def test_group_list_dictize_including_tags(self):
factories.Group()
# group tags aren't in the group_create schema, so its slightly more
# convoluted way to create them
group_obj = model.Session.query(model.Group).first()
tag = model.Tag(name='t1')
model.Session.add(tag)
model.Session.commit()
tag = model.Session.query(model.Tag).first()
group_obj = model.Session.query(model.Group).first()
member = model.Member(group=group_obj, table_id=tag.id,
table_name='tag')
model.Session.add(member)
model.repo.new_revision()
model.Session.commit()
group_list = model.Session.query(model.Group).filter_by().all()
context = {'model': model, 'session': model.Session}
group_dicts = model_dictize.group_list_dictize(group_list, context,
include_tags=True)
assert_equal(group_dicts[0]['tags'][0]['name'], 't1')
def showings_list_admin(context, data_dict):
'''
Return a list of showings groups for which the authorized user is admin.
This is like login.action.get.group_list_authz, but without being tied up
with 'organizations' conditionals.
'''
model = context['model']
user = context['user']
toolkit.check_access('group_list_authz', context, data_dict)
if new_authz.auth_is_loggedin_user():
user_id = new_authz.get_user_id_for_username(user.get('name'), allow_none=True)
else:
return []
if user_id is None:
return []
q = model.Session.query(model.Member) \
.filter(model.Member.table_name == 'user') \
.filter(model.Member.capacity == 'admin') \
.filter(model.Member.table_id == user_id)
group_ids = [row.group_id for row in q.all()]
if not group_ids:
return []
q = model.Session.query(model.Group) \
.filter(model.Group.type == 'showing') \
.filter(model.Group.state == 'active')
groups = q.filter(model.Group.id.in_(group_ids)).all()
group_list = model_dictize.group_list_dictize(groups, context)
return group_list
def organization_list_for_user(context, data_dict):
'''Return the list of organizations that the user is a member of.
:param permission: the permission the user has against the returned organizations
(optional, default: ``edit_group``)
:type permission: string
:returns: list of dictized organizations that the user is authorized to edit
:rtype: list of dicts
'''
model = context['model']
user = context['user']
_check_access('organization_list_for_user',context, data_dict)
sysadmin = new_authz.is_sysadmin(user)
orgs_q = model.Session.query(model.Group) \
.filter(model.Group.is_organization == True) \
.filter(model.Group.state == 'active')
if not sysadmin:
# for non-Sysadmins check they have the required permission
permission = data_dict.get('permission', 'edit_group')
roles = ckan.new_authz.get_roles_with_permission(permission)
if not roles:
return []
user_id = new_authz.get_user_id_for_username(user, allow_none=True)
if not user_id:
return []
q = model.Session.query(model.Member) \
.filter(model.Member.table_name == 'user') \
.filter(model.Member.capacity.in_(roles)) \
.filter(model.Member.table_id == user_id) \
.filter(model.Member.state == 'active')
group_ids = []
for row in q.all():
group_ids.append(row.group_id)
if not group_ids:
return []
orgs_q = orgs_q.filter(model.Group.id.in_(group_ids))
orgs_list_complete = orgs_q.all()
orgs_list = model_dictize.group_list_dictize(orgs_list_complete, context)
#to be used in case we want to display the created field
# org_list_map ={}
# for it in orgs_list_complete:
# org_list_map[it.id]=it
# for it in orgs_list:
# id=it['id']
# org = org_list_map[id]
# it['created']=org.created.isoformat()
return orgs_list
def group_list_authz(context, data_dict):
''' Return the list of groups that the user is authorized to edit.
Action "group_list_authz" ovewrites core "group_list_authz" action.
It does so in order to allow users, other than the sysadmin, add/delete
members to/from a thematic group. The only precondition to that right,
is the user having at least editor rights for at least one organization.
:param available_only: remove the existing groups in the package
(optional, default: ``False``)
:type available_only: boolean
:param am_member: if True return only the groups the logged-in user is a
member of, otherwise return all groups that the user is authorized to
edit (for example, sysadmin users are authorized to edit all groups)
(optional, default: False)
:type am-member: boolean
:returns: list of dictized groups that the user is authorized to edit
:rtype: list of dicts
'''
model = context['model']
user = context['user']
available_only = data_dict.get('available_only', False)
am_member = data_dict.get('am_member', False)
_check_access('group_list_authz',context, data_dict)
sysadmin = new_authz.is_sysadmin(user)
roles = new_authz.get_roles_with_permission('update_dataset')
if not roles:
return []
user_id = new_authz.get_user_id_for_username(user, allow_none=True)
if not user_id:
return []
if not sysadmin or am_member:
q = model.Session.query(model.Member) \
.filter(model.Member.table_name == 'user') \
.filter(model.Member.capacity.in_(roles)) \
.filter(model.Member.table_id == user_id)
group_ids = []
for row in q.all():
group_ids.append(row.group_id)
if not group_ids:
return []
if context.get('package'):
package_org = context.get('package').owner_org
if package_org not in group_ids:
return []
q = model.Session.query(model.Group) \
.filter(model.Group.is_organization == False) \
.filter(model.Group.state == 'active')
groups = q.all()
if available_only:
package = context.get('package')
if package:
groups = set(groups) - set(package.get_groups())
group_list = model_dictize.group_list_dictize(groups, context)
return group_list
def topics_list_for_user(context, data_dict):
'''Return the all types of groups that the user has a given permission for.
By default this returns the list of all types of groups that the currently
authorized user can edit, i.e. the list of all types of groups that the user is an
admin of.
Specifically it returns the list of all types of groups that the currently
authorized user has a given permission (for example: "manage_group") against.
When a user becomes a member of a group in CKAN they're given a
"capacity" (sometimes called a "role"), for example "member", "editor" or
"admin".
Each of these roles has certain permissions associated with it. For example
the admin role has the "admin" permission (which means they have permission
to do anything). The editor role has permissions like "create_dataset",
"update_dataset" and "delete_dataset". The member role has the "read"
permission.
This function returns the list of all types of groups that the authorized user
has a given permission for. For example the list of all types of groups that the
user is an admin of, or the list of all types of groups that the user can create
datasets in. This takes account of when permissions cascade down an
all types of groups hierarchy.
:param permission: the permission the user has against the
returned organizations, for example ``"read"`` or ``"create_dataset"``
(optional, default: ``"edit_group"``)
:type permission: string
:returns: list of all types of groups that the user has the given permission for
:rtype: list of dicts
'''
model = context['model']
user = context['user']
_check_access('organization_list_for_user', context, data_dict)
sysadmin = authz.is_sysadmin(user)
topics_q = model.Session.query(model.Group) \
.filter(model.Group.type == "topics") \
.filter(model.Group.state == 'active')
"""
if not sysadmin:
# for non-Sysadmins check they have the required permission
# NB 'edit_group' doesn't exist so by default this action returns just
# orgs with admin role
permission = data_dict.get('permission', 'edit_group')
roles = authz.get_roles_with_permission(permission)
if not roles:
return []
user_id = authz.get_user_id_for_username(user, allow_none=True)
if not user_id:
return []
q = model.Session.query(model.Member, model.Group) \
.filter(model.Member.table_name == 'user') \
.filter(model.Member.capacity.in_(roles)) \
.filter(model.Member.table_id == user_id) \
.filter(model.Member.state == 'active') \
.join(model.Group)
group_ids = set()
roles_that_cascade = \
authz.check_config_permission('roles_that_cascade_to_sub_groups')
for member, group in q.all():
if member.capacity in roles_that_cascade:
group_ids |= set([
grp_tuple[0] for grp_tuple
in group.get_children_group_hierarchy(type='topics')
])
group_ids.add(group.id)
if not group_ids:
return []
topics_q = topics_q.filter(model.Group.id.in_(group_ids))
"""
orgs_list = model_dictize.group_list_dictize(topics_q.all(), context)
for o in orgs_list:
o['title'] = o['title'].decode('utf_8')
return orgs_list
def organization_list_related(self, ver=None):
'''
Returns the list of organizations including parent_of and child_of relationships.
'''
# FIXME: use IActions plugin instead
from ckan.lib.search import SearchError
help_str = "Return a list of the names of the site's organizations.\n\n" + \
":param order_by: the field to sort the list by, must be ``'name'`` or \n" + \
" ``'packages'`` (optional, default: ``'name'``) Deprecated use sort. \n" + \
":type order_by: string \n" + \
":param sort: sorting of the search results. Optional. Default:\n" + \
"'name asc' string of field name and sort-order. The allowed fields are \n" + \
"'name' and 'packages' \n" + \
":type sort: string \n" + \
":param organizations: a list of names of the groups to return, if given only \n" + \
"groups whose names are in this list will be returned (optional) \n" + \
":type organizations: list of strings \n" + \
":param all_fields: return full group dictionaries instead of just names \n" + \
"(optional, default: ``False``) \n" + \
":type all_fields: boolean \n" + \
":rtype: list of strings \n"
return_dict = {"help": help_str}
data_dict = self._get_request_data(try_url_params=True)
all_fields = data_dict.get('all_fields', False)
order_by = data_dict.get('order_by', 'name')
sort = data_dict.get('sort', 'name asc')
organizations = data_dict.get('organizations', [])
context = {'model': model, 'session': model.Session, 'user': c.user,
'api_version': ver, 'auth_user_obj': c.userobj}
org_list = get_action('organization_list')(context, data_dict)
if (all_fields):
#add the child orgs to the response:
for org in org_list:
children = []
branches = get_organization_branches(org['id'])
group_list = model_dictize.group_list_dictize(branches, context)
for branch in group_list:
d = {}
d['title'] = branch['title']
children.append(d)
org['parent_of'] = children
parents = []
branches = get_parent_orgs(org['id'])
group_list = model_dictize.group_list_dictize(branches, context)
for branch in group_list:
d = {}
d['title'] = branch['title']
parents.append(d)
org['child_of'] = parents
return_dict['success'] = True
return_dict['result'] = org_list
return self._finish_ok(return_dict)
def package_dictize_with_revisions(pkg, context):
'''
Given a Package object, returns an equivalent dictionary.
Normally this is the most recent version, but you can provide revision_id
or revision_date in the context and it will filter to an earlier time.
May raise NotFound if:
* the specified revision_id doesn't exist
* the specified revision_date was before the package was created
'''
model = context['model']
is_latest_revision = not(context.get(u'revision_id') or
context.get(u'revision_date'))
execute = _execute if is_latest_revision else _execute_with_revision
# package
if is_latest_revision:
if isinstance(pkg, revision_model.PackageRevision):
pkg = model.Package.get(pkg.id)
result = pkg
else:
package_rev = revision_model.package_revision_table
q = select([package_rev]).where(package_rev.c.id == pkg.id)
result = execute(q, package_rev, context).first()
if not result:
raise logic.NotFound
result_dict = d.table_dictize(result, context)
# strip whitespace from title
if result_dict.get(u'title'):
result_dict['title'] = result_dict['title'].strip()
# resources
if is_latest_revision:
res = model.resource_table
else:
res = revision_model.resource_revision_table
q = select([res]).where(res.c.package_id == pkg.id)
result = execute(q, res, context)
result_dict["resources"] = resource_list_dictize(result, context)
result_dict['num_resources'] = len(result_dict.get(u'resources', []))
# tags
tag = model.tag_table
if is_latest_revision:
pkg_tag = model.package_tag_table
else:
pkg_tag = revision_model.package_tag_revision_table
q = select([tag, pkg_tag.c.state],
from_obj=pkg_tag.join(tag, tag.c.id == pkg_tag.c.tag_id)
).where(pkg_tag.c.package_id == pkg.id)
result = execute(q, pkg_tag, context)
result_dict["tags"] = d.obj_list_dictize(result, context,
lambda x: x["name"])
result_dict['num_tags'] = len(result_dict.get(u'tags', []))
# Add display_names to tags. At first a tag's display_name is just the
# same as its name, but the display_name might get changed later (e.g.
# translated into another language by the multilingual extension).
for tag in result_dict['tags']:
assert u'display_name' not in tag
tag['display_name'] = tag['name']
# extras
if is_latest_revision:
extra = model.package_extra_table
else:
extra = revision_model.extra_revision_table
q = select([extra]).where(extra.c.package_id == pkg.id)
result = execute(q, extra, context)
result_dict["extras"] = extras_list_dictize(result, context)
# groups
if is_latest_revision:
member = model.member_table
else:
member = revision_model.member_revision_table
group = model.group_table
q = select([group, member.c.capacity],
from_obj=member.join(group, group.c.id == member.c.group_id)
).where(member.c.table_id == pkg.id)\
.where(member.c.state == u'active') \
.where(group.c.is_organization == False) # noqa
result = execute(q, member, context)
context['with_capacity'] = False
# no package counts as cannot fetch from search index at the same
# time as indexing to it.
# tags, extras and sub-groups are not included for speed
result_dict["groups"] = group_list_dictize(result, context,
with_package_counts=False)
# owning organization
if is_latest_revision:
group = model.group_table
else:
group = revision_model.group_revision_table
q = select([group]
).where(group.c.id == result_dict['owner_org']) \
.where(group.c.state == u'active')
result = execute(q, group, context)
organizations = d.obj_list_dictize(result, context)
if organizations:
result_dict["organization"] = organizations[0]
else:
result_dict["organization"] = None
# relations
if is_latest_revision:
rel = model.package_relationship_table
else:
rel = revision_model \
.package_relationship_revision_table
q = select([rel]).where(rel.c.subject_package_id == pkg.id)
result = execute(q, rel, context)
result_dict["relationships_as_subject"] = \
d.obj_list_dictize(result, context)
q = select([rel]).where(rel.c.object_package_id == pkg.id)
result = execute(q, rel, context)
result_dict["relationships_as_object"] = \
d.obj_list_dictize(result, context)
# Extra properties from the domain object
# We need an actual Package object for this, not a PackageRevision
# if isinstance(pkg, model.PackageRevision):
# pkg = model.Package.get(pkg.id)
# isopen
result_dict['isopen'] = pkg.isopen if isinstance(pkg.isopen, bool) \
else pkg.isopen()
# type
# if null assign the default value to make searching easier
result_dict['type'] = pkg.type or u'dataset'
# license
if pkg.license and pkg.license.url:
result_dict['license_url'] = pkg.license.url
result_dict['license_title'] = pkg.license.title.split(u'::')[-1]
elif pkg.license:
result_dict['license_title'] = pkg.license.title
else:
result_dict['license_title'] = pkg.license_id
# creation and modification date
if is_latest_revision:
result_dict['metadata_modified'] = pkg.metadata_modified.isoformat()
# (If not is_latest_revision, don't use pkg which is the latest version.
# Instead, use the dates already in result_dict that came from the dictized
# PackageRevision)
result_dict['metadata_created'] = pkg.metadata_created.isoformat()
return result_dict
def _approval_needed(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'
sort = data_dict.get('sort', '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 == 'approval_needed')
if groups:
query = query.filter(model.Group.name.in_(groups))
if q:
q = u'%{0}%'.format(q)
query = query.filter(_or_(
model.Group.name.ilike(q),
model.Group.title.ilike(q),
model.Group.description.ilike(q),
))
query = query.filter(model.Group.is_organization == is_org)
if not is_org:
query = query.filter(model.Group.type == group_type)
groups = query.all()
if all_fields:
include_tags = asbool(data_dict.get('include_tags', False))
else:
include_tags = False
# even if we are not going to return all_fields, we need to dictize all the
# groups so that we can sort by any field.
group_list = model_dictize.group_list_dictize(
groups, context,
sort_key=lambda x: x[sort_info[0][0]],
reverse=sort_info[0][1] == 'desc',
with_package_counts=all_fields or
sort_info[0][0] in ('packages', 'package_count'),
include_groups=asbool(data_dict.get('include_groups', False)),
include_tags=include_tags,
include_extras=include_extras,
)
if not all_fields:
group_list = [group[ref_group_by] for group in group_list]
return group_list
