def follow_dataset(context, data_dict):
'''Start following a dataset.
You must provide your API key in the Authorization header.
:param id: the id or name of the dataset to follow, e.g. ``'warandpeace'``
:type id: string
:returns: a representation of the 'follower' relationship between yourself
and the dataset
:rtype: dictionary
'''
if not context.has_key('user'):
raise logic.NotAuthorized(
_("You must be logged in to follow a dataset."))
model = context['model']
session = context['session']
userobj = model.User.get(context['user'])
if not userobj:
raise logic.NotAuthorized(
_("You must be logged in to follow a dataset."))
schema = (context.get('schema')
or ckan.logic.schema.default_follow_dataset_schema())
validated_data_dict, errors = _validate(data_dict, schema, context)
if errors:
model.Session.rollback()
raise ValidationError(errors)
# Don't let a user follow a dataset she is already following.
if model.UserFollowingDataset.is_following(userobj.id,
validated_data_dict['id']):
# FIXME really package model should have this logic and provide
# 'display_name' like users and groups
pkgobj = model.Package.get(validated_data_dict['id'])
name = pkgobj.title or pkgobj.name or pkgobj.id
message = _(
'You are already following {0}').format(name)
raise ValidationError({'message': message}, error_summary=message)
follower = model_save.follower_dict_save(validated_data_dict, context,
model.UserFollowingDataset)
if not context.get('defer_commit'):
model.repo.commit()
log.debug(u'User {follower} started following dataset {object}'.format(
follower=follower.follower_id, object=follower.object_id))
return model_dictize.user_following_dataset_dictize(follower, context)
def follow_user(context, data_dict):
'''Start following another user.
You must provide your API key in the Authorization header.
:param id: the id or name of the user to follow, e.g. ``'joeuser'``
:type id: string
:returns: a representation of the 'follower' relationship between yourself
and the other user
:rtype: dictionary
'''
if 'user' not in context:
raise logic.NotAuthorized(_("You must be logged in to follow users"))
model = context['model']
session = context['session']
userobj = model.User.get(context['user'])
if not userobj:
raise logic.NotAuthorized(_("You must be logged in to follow users"))
schema = (context.get('schema')
or ckan.logic.schema.default_follow_user_schema())
validated_data_dict, errors = _validate(data_dict, schema, context)
if errors:
model.Session.rollback()
raise ValidationError(errors)
# Don't let a user follow herself.
if userobj.id == validated_data_dict['id']:
message = _('You cannot follow yourself')
raise ValidationError({'message': message}, error_summary=message)
# Don't let a user follow someone she is already following.
if model.UserFollowingUser.is_following(userobj.id,
validated_data_dict['id']):
followeduserobj = model.User.get(validated_data_dict['id'])
name = followeduserobj.display_name
message = _(
'You are already following {0}').format(name)
raise ValidationError({'message': message}, error_summary=message)
follower = model_save.follower_dict_save(validated_data_dict, context,
model.UserFollowingUser)
if not context.get('defer_commit'):
model.repo.commit()
log.debug(u'User {follower} started following user {object}'.format(
follower=follower.follower_id, object=follower.object_id))
return model_dictize.user_following_user_dictize(follower, context)
def follow_dataset(context, data_dict):
'''Start following a dataset.
You must provide your API key in the Authorization header.
:param id: the id or name of the dataset to follow, e.g. ``'warandpeace'``
:type id: string
:returns: a representation of the 'follower' relationship between yourself
and the dataset
:rtype: dictionary
'''
if not 'user' in context:
raise logic.NotAuthorized(
_("You must be logged in to follow a dataset."))
model = context['model']
session = context['session']
userobj = model.User.get(context['user'])
if not userobj:
raise logic.NotAuthorized(
_("You must be logged in to follow a dataset."))
schema = (context.get('schema')
or ckan.logic.schema.default_follow_dataset_schema())
validated_data_dict, errors = _validate(data_dict, schema, context)
if errors:
model.Session.rollback()
raise ValidationError(errors)
# Don't let a user follow a dataset she is already following.
if model.UserFollowingDataset.is_following(userobj.id,
validated_data_dict['id']):
# FIXME really package model should have this logic and provide
# 'display_name' like users and groups
pkgobj = model.Package.get(validated_data_dict['id'])
name = pkgobj.title or pkgobj.name or pkgobj.id
message = _(
'You are already following {0}').format(name)
raise ValidationError({'message': message}, error_summary=message)
follower = model_save.follower_dict_save(validated_data_dict, context,
model.UserFollowingDataset)
if not context.get('defer_commit'):
model.repo.commit()
log.debug(u'User {follower} started following dataset {object}'.format(
follower=follower.follower_id, object=follower.object_id))
return model_dictize.user_following_dataset_dictize(follower, context)
def follow_user(context, data_dict):
'''Start following another user.
You must provide your API key in the Authorization header.
:param id: the id or name of the user to follow, e.g. ``'joeuser'``
:type id: string
:returns: a representation of the 'follower' relationship between yourself
and the other user
:rtype: dictionary
'''
if 'user' not in context:
raise logic.NotAuthorized(_("You must be logged in to follow users"))
model = context['model']
session = context['session']
userobj = model.User.get(context['user'])
if not userobj:
raise logic.NotAuthorized(_("You must be logged in to follow users"))
schema = (context.get('schema')
or ckan.logic.schema.default_follow_user_schema())
validated_data_dict, errors = _validate(data_dict, schema, context)
if errors:
model.Session.rollback()
raise ValidationError(errors)
# Don't let a user follow herself.
if userobj.id == validated_data_dict['id']:
message = _('You cannot follow yourself')
raise ValidationError({'message': message}, error_summary=message)
# Don't let a user follow someone she is already following.
if model.UserFollowingUser.is_following(userobj.id,
validated_data_dict['id']):
followeduserobj = model.User.get(validated_data_dict['id'])
name = followeduserobj.display_name
message = _(
'You are already following {0}').format(name)
raise ValidationError({'message': message}, error_summary=message)
follower = model_save.follower_dict_save(validated_data_dict, context,
model.UserFollowingUser)
if not context.get('defer_commit'):
model.repo.commit()
log.debug(u'User {follower} started following user {object}'.format(
follower=follower.follower_id, object=follower.object_id))
return model_dictize.user_following_user_dictize(follower, context)
def follow_group(context, data_dict):
"""Start following a group.
You must provide your API key in the Authorization header.
:param id: the id or name of the group to follow, e.g. ``'roger'``
:type id: string
:returns: a representation of the 'follower' relationship between yourself
and the group
:rtype: dictionary
"""
if "user" not in context:
raise logic.NotAuthorized(_("You must be logged in to follow a group."))
model = context["model"]
session = context["session"]
userobj = model.User.get(context["user"])
if not userobj:
raise logic.NotAuthorized(_("You must be logged in to follow a group."))
schema = context.get("schema", ckan.logic.schema.default_follow_group_schema())
validated_data_dict, errors = _validate(data_dict, schema, context)
if errors:
model.Session.rollback()
raise ValidationError(errors)
# Don't let a user follow a group she is already following.
if model.UserFollowingGroup.is_following(userobj.id, validated_data_dict["id"]):
groupobj = model.Group.get(validated_data_dict["id"])
name = groupobj.display_name
message = _("You are already following {0}").format(name)
raise ValidationError({"message": message}, error_summary=message)
follower = model_save.follower_dict_save(validated_data_dict, context, model.UserFollowingGroup)
if not context.get("defer_commit"):
model.repo.commit()
log.debug(
u"User {follower} started following group {object}".format(
follower=follower.follower_id, object=follower.object_id
)
)
return model_dictize.user_following_group_dictize(follower, context)
def follow_dataset(context, data_dict):
'''Start following a dataset.
You must provide your API key in the Authorization header.
:param id: the id or name of the dataset to follow, e.g. ``'warandpeace'``
:type id: string
:returns: a representation of the 'follower' relationship between yourself
and the dataset
:rtype: dictionary
'''
if not context.has_key('user'):
raise logic.NotAuthorized(
_("You must be logged in to follow a dataset."))
model = context['model']
session = context['session']
userobj = model.User.get(context['user'])
if not userobj:
raise logic.NotAuthorized(
_("You must be logged in to follow a dataset."))
schema = (context.get('schema')
or ckan.logic.schema.default_follow_dataset_schema())
validated_data_dict, errors = _validate(data_dict, schema, context)
if errors:
model.Session.rollback()
raise ValidationError(errors)
# Don't let a user follow a dataset she is already following.
if model.UserFollowingDataset.is_following(userobj.id,
validated_data_dict['id']):
message = _(
'You are already following {0}').format(data_dict['id'])
raise ValidationError({'message': message}, error_summary=message)
follower = model_save.follower_dict_save(validated_data_dict, context,
model.UserFollowingDataset)
activity_dict = {
'user_id': userobj.id,
'object_id': validated_data_dict['id'],
'activity_type': 'follow dataset',
}
activity_dict['data'] = {
'dataset': ckan.lib.dictization.table_dictize(
model.Package.get(validated_data_dict['id']), context),
}
activity_create_context = {
'model': model,
'user': userobj,
'defer_commit':True,
'session': session
}
logic.get_action('activity_create')(activity_create_context,
activity_dict, ignore_auth=True)
if not context.get('defer_commit'):
model.repo.commit()
log.debug(u'User {follower} started following dataset {object}'.format(
follower=follower.follower_id, object=follower.object_id))
return model_dictize.user_following_dataset_dictize(follower, context)
def follow_dataset(context, data_dict):
'''Start following a dataset.
You must provide your API key in the Authorization header.
:param id: the id or name of the dataset to follow, e.g. ``'warandpeace'``
:type id: string
:returns: a representation of the 'follower' relationship between yourself
and the dataset
:rtype: dictionary
'''
if not context.has_key('user'):
raise logic.NotAuthorized(
_("You must be logged in to follow a dataset."))
model = context['model']
session = context['session']
userobj = model.User.get(context['user'])
if not userobj:
raise logic.NotAuthorized(
_("You must be logged in to follow a dataset."))
schema = (context.get('schema')
or ckan.logic.schema.default_follow_dataset_schema())
validated_data_dict, errors = _validate(data_dict, schema, context)
if errors:
model.Session.rollback()
raise ValidationError(errors)
# Don't let a user follow a dataset she is already following.
if model.UserFollowingDataset.is_following(userobj.id,
validated_data_dict['id']):
message = _('You are already following {0}').format(data_dict['id'])
raise ValidationError({'message': message}, error_summary=message)
follower = model_save.follower_dict_save(validated_data_dict, context,
model.UserFollowingDataset)
activity_dict = {
'user_id': userobj.id,
'object_id': validated_data_dict['id'],
'activity_type': 'follow dataset',
}
activity_dict['data'] = {
'dataset':
ckan.lib.dictization.table_dictize(
model.Package.get(validated_data_dict['id']), context),
}
activity_create_context = {
'model': model,
'user': userobj,
'defer_commit': True,
'session': session
}
logic.get_action('activity_create')(activity_create_context,
activity_dict,
ignore_auth=True)
if not context.get('defer_commit'):
model.repo.commit()
log.debug(u'User {follower} started following dataset {object}'.format(
follower=follower.follower_id, object=follower.object_id))
return model_dictize.user_following_dataset_dictize(follower, context)
