def user_update(context, data_dict):
"""Updates the user\'s details"""
model = context["model"]
user = context["user"]
session = context["session"]
schema = context.get("schema") or default_update_user_schema()
id = data_dict["id"]
user_obj = model.User.get(id)
context["user_obj"] = user_obj
if user_obj is None:
raise NotFound("User was not found.")
check_access("user_update", context, data_dict)
data, errors = validate(data_dict, schema, context)
if errors:
session.rollback()
raise ValidationError(errors, group_error_summary(errors))
user = user_dict_save(data, context)
activity_dict = {"user_id": user.id, "object_id": user.id, "activity_type": "changed user"}
activity_create_context = {"model": model, "user": user, "defer_commit": True, "session": session}
from ckan.logic.action.create import activity_create
activity_create(activity_create_context, activity_dict, ignore_auth=True)
# TODO: Also create an activity detail recording what exactly changed in
# the user.
if not context.get("defer_commit"):
model.repo.commit()
return user_dictize(user, context)
def user_create(context, data_dict):
model = context['model']
schema = context.get('schema') or ckan.logic.schema.default_user_schema()
session = context['session']
_check_access('user_create', context, data_dict)
data, errors = _validate(data_dict, schema, context)
if errors:
session.rollback()
raise ValidationError(errors)
if 'password_hash' in data:
data['_password'] = data.pop('password_hash')
user = model_save.user_dict_save(data, context)
if user.email == pylons.config.get('ckan.loopback.email'):
raise ValidationError({'Email Address': ['Invalid email address.']})
session.flush()
loopback_user_create({
'id': user.id,
'username': user.name,
'email': user.email,
'apikey': user.apikey,
'password': data['password']
})
activity_create_context = {
'model': model,
'user': context['user'],
'defer_commit': True,
'ignore_auth': True,
'session': session
}
activity_dict = {
'user_id': user.id,
'object_id': user.id,
'activity_type': 'new user',
}
logic.get_action('activity_create')(activity_create_context, activity_dict)
if not context.get('defer_commit'):
model.repo.commit()
user_dictize_context = context.copy()
user_dictize_context['keep_apikey'] = True
user_dictize_context['keep_email'] = True
user_dict = model_dictize.user_dictize(user, user_dictize_context)
context['user_obj'] = user
context['id'] = user.id
model.Dashboard.get(user.id)
log.debug('CKAN user created: {}'.format(user.name))
return user_dict
def user_update(context, data_dict):
'''Updates the user\'s details'''
model = context['model']
user = context['user']
schema = context.get('schema') or default_update_user_schema()
id = data_dict['id']
user_obj = model.User.get(id)
context['user_obj'] = user_obj
if user_obj is None:
raise NotFound('User was not found.')
check_access('user_update', context, data_dict)
data, errors = validate(data_dict, schema, context)
if errors:
model.Session.rollback()
raise ValidationError(errors, group_error_summary(errors))
user = user_dict_save(data, context)
if not context.get('defer_commit'):
model.repo.commit()
return user_dictize(user, context)
def user_create(context, data_dict):
"""Creates a new user"""
model = context["model"]
schema = context.get("schema") or ckan.logic.schema.default_user_schema()
session = context["session"]
check_access("user_create", context, data_dict)
data, errors = validate(data_dict, schema, context)
if errors:
session.rollback()
raise ValidationError(errors, error_summary(errors))
user = model_save.user_dict_save(data, context)
# Flush the session to cause user.id to be initialised, because
# activity_create() (below) needs it.
session.flush()
activity_create_context = {"model": model, "user": context["user"], "defer_commit": True, "session": session}
activity_dict = {"user_id": user.id, "object_id": user.id, "activity_type": "new user"}
activity_create(activity_create_context, activity_dict, ignore_auth=True)
if not context.get("defer_commit"):
model.repo.commit()
context["user"] = user
context["id"] = user.id
log.debug("Created user %s" % str(user.name))
return model_dictize.user_dictize(user, context)
def user_update(context, data_dict):
'''Update a user account.
Normal users can only update their own user accounts. Sysadmins can update
any user account.
For further parameters see
:py:func:`~ckan.logic.action.create.user_create`.
:param id: the name or id of the user to update
:type id: string
:returns: the updated user account
:rtype: dictionary
'''
model = context['model']
user = context['user']
session = context['session']
schema = context.get('schema') or schema_.default_update_user_schema()
id = _get_or_bust(data_dict, 'id')
user_obj = model.User.get(id)
context['user_obj'] = user_obj
if user_obj is None:
raise NotFound('User was not found.')
_check_access('user_update', context, data_dict)
data, errors = _validate(data_dict, schema, context)
if errors:
session.rollback()
raise ValidationError(errors)
# user schema prevents non-sysadmins from providing password_hash
if 'password_hash' in data:
data['_password'] = data.pop('password_hash')
user = model_save.user_dict_save(data, context)
activity_dict = {
'user_id': user.id,
'object_id': user.id,
'activity_type': 'changed user',
}
activity_create_context = {
'model': model,
'user': user,
'defer_commit': True,
'ignore_auth': True,
'session': session
}
_get_action('activity_create')(activity_create_context, activity_dict)
# TODO: Also create an activity detail recording what exactly changed in
# the user.
if not context.get('defer_commit'):
model.repo.commit()
return model_dictize.user_dictize(user, context)
def user_update(context, data_dict):
'''Update a user account.
Normal users can only update their own user accounts. Sysadmins can update
any user account.
For further parameters see
:py:func:`~ckan.logic.action.create.user_create`.
:param id: the name or id of the user to update
:type id: string
:returns: the updated user account
:rtype: dictionary
'''
model = context['model']
user = context['user']
session = context['session']
schema = context.get('schema') or schema_.default_update_user_schema()
id = _get_or_bust(data_dict, 'id')
user_obj = model.User.get(id)
context['user_obj'] = user_obj
if user_obj is None:
raise NotFound('User was not found.')
_check_access('user_update', context, data_dict)
data, errors = _validate(data_dict, schema, context)
if errors:
session.rollback()
raise ValidationError(errors)
# user schema prevents non-sysadmins from providing password_hash
if 'password_hash' in data:
data['_password'] = data.pop('password_hash')
user = model_save.user_dict_save(data, context)
activity_dict = {
'user_id': user.id,
'object_id': user.id,
'activity_type': 'changed user',
}
activity_create_context = {
'model': model,
'user': user,
'defer_commit': True,
'ignore_auth': True,
'session': session
}
_get_action('activity_create')(activity_create_context, activity_dict)
# TODO: Also create an activity detail recording what exactly changed in
# the user.
if not context.get('defer_commit'):
model.repo.commit()
return model_dictize.user_dictize(user, context)
def user_create(context, data_dict):
model = context['model']
schema = context.get('schema') or ckan.logic.schema.default_user_schema()
session = context['session']
_check_access('user_create', context, data_dict)
data, errors = _validate(data_dict, schema, context)
if errors:
session.rollback()
raise ValidationError(errors)
if 'password_hash' in data:
data['_password'] = data.pop('password_hash')
user = model_save.user_dict_save(data, context)
if user.email == pylons.config.get('ckan.loopback.email'):
raise ValidationError({'Email Address': ['Invalid email address.']})
session.flush()
loopback_user_create({
'id': user.id,
'username': user.name,
'email': user.email,
'password': data['password']
})
activity_create_context = {
'model': model,
'user': context['user'],
'defer_commit': True,
'ignore_auth': True,
'session': session
}
activity_dict = {
'user_id': user.id,
'object_id': user.id,
'activity_type': 'new user',
}
logic.get_action('activity_create')(activity_create_context, activity_dict)
if not context.get('defer_commit'):
model.repo.commit()
user_dictize_context = context.copy()
user_dictize_context['keep_apikey'] = True
user_dictize_context['keep_email'] = True
user_dict = model_dictize.user_dictize(user, user_dictize_context)
context['user_obj'] = user
context['id'] = user.id
model.Dashboard.get(user.id)
log.debug('CKAN user created: {}'.format(user.name))
return user_dict
def user_update(context, data_dict):
model = context['model']
user = context['user']
session = context['session']
schema = context.get('schema') or schema_.default_update_user_schema()
id = _get_or_bust(data_dict, 'id')
user_obj = model.User.get(id)
context['user_obj'] = user_obj
if user_obj is None:
raise NotFound('User was not found.')
_check_access('user_update', context, data_dict)
data, errors = _validate(data_dict, schema, context)
if errors:
session.rollback()
raise ValidationError(errors)
if 'password_hash' in data:
data['_password'] = data.pop('password_hash')
user = model_save.user_dict_save(data, context)
if user.name == pylons.config.get('ckan.loopback.username'):
raise ValidationError({'Username': ['Invalid username.']})
loopback_user_info = {
'username': user.name,
'email': user.email,
'apikey': user.apikey
}
if 'password' in data:
loopback_user_info['password'] = data['password']
loopback_user_update(user.id, loopback_user_info)
activity_dict = {
'user_id': user.id,
'object_id': user.id,
'activity_type': 'changed user',
}
activity_create_context = {
'model': model,
'user': user,
'defer_commit': True,
'ignore_auth': True,
'session': session
}
_get_action('activity_create')(activity_create_context, activity_dict)
if not context.get('defer_commit'):
model.repo.commit()
log.debug('CKAN user updated: {}'.format(user.name))
return model_dictize.user_dictize(user, context)
def user_update(context, data_dict):
model = context['model']
user = context['user']
session = context['session']
schema = context.get('schema') or schema_.default_update_user_schema()
id = _get_or_bust(data_dict, 'id')
user_obj = model.User.get(id)
context['user_obj'] = user_obj
if user_obj is None:
raise NotFound('User was not found.')
_check_access('user_update', context, data_dict)
data, errors = _validate(data_dict, schema, context)
if errors:
session.rollback()
raise ValidationError(errors)
if 'password_hash' in data:
data['_password'] = data.pop('password_hash')
user = model_save.user_dict_save(data, context)
if user.name == pylons.config.get('ckan.loopback.username'):
raise ValidationError({'Username': ['Invalid username.']})
loopback_user_info = {
'username': user.name,
'email': user.email
}
if 'password' in data:
loopback_user_info['password'] = data['password']
loopback_user_update(user.id, loopback_user_info)
activity_dict = {
'user_id': user.id,
'object_id': user.id,
'activity_type': 'changed user',
}
activity_create_context = {
'model': model,
'user': user,
'defer_commit': True,
'ignore_auth': True,
'session': session
}
_get_action('activity_create')(activity_create_context, activity_dict)
if not context.get('defer_commit'):
model.repo.commit()
log.debug('CKAN user updated: {}'.format(user.name))
return model_dictize.user_dictize(user, context)
def user_update(context, data_dict):
"""Update a user account.
Normal users can only update their own user accounts. Sysadmins can update
any user account.
For further parameters see
:py:func:`~ckan.logic.action.create.user_create`.
:param id: the name or id of the user to update
:type id: string
:returns: the updated user account
:rtype: dictionary
"""
model = context["model"]
user = context["user"]
session = context["session"]
schema = context.get("schema") or schema_.default_update_user_schema()
id = _get_or_bust(data_dict, "id")
user_obj = model.User.get(id)
context["user_obj"] = user_obj
if user_obj is None:
raise NotFound("User was not found.")
_check_access("user_update", context, data_dict)
data, errors = _validate(data_dict, schema, context)
if errors:
session.rollback()
raise ValidationError(errors)
# user schema prevents non-sysadmins from providing password_hash
if "password_hash" in data:
data["_password"] = data.pop("password_hash")
user = model_save.user_dict_save(data, context)
activity_dict = {"user_id": user.id, "object_id": user.id, "activity_type": "changed user"}
activity_create_context = {
"model": model,
"user": user,
"defer_commit": True,
"ignore_auth": True,
"session": session,
}
_get_action("activity_create")(activity_create_context, activity_dict)
# TODO: Also create an activity detail recording what exactly changed in
# the user.
if not context.get("defer_commit"):
model.repo.commit()
return model_dictize.user_dictize(user, context)
def user_update(context, data_dict):
'''Updates the user\'s details'''
model = context['model']
user = context['user']
session = context['session']
schema = context.get(
'schema') or ckan.logic.schema.default_update_user_schema()
id = data_dict['id']
user_obj = model.User.get(id)
context['user_obj'] = user_obj
if user_obj is None:
raise NotFound('User was not found.')
check_access('user_update', context, data_dict)
data, errors = validate(data_dict, schema, context)
if errors:
session.rollback()
raise ValidationError(errors, error_summary(errors))
user = model_save.user_dict_save(data, context)
activity_dict = {
'user_id': user.id,
'object_id': user.id,
'activity_type': 'changed user',
}
activity_create_context = {
'model': model,
'user': user,
'defer_commit': True,
'session': session
}
get_action('activity_create')(activity_create_context,
activity_dict,
ignore_auth=True)
# TODO: Also create an activity detail recording what exactly changed in
# the user.
if not context.get('defer_commit'):
model.repo.commit()
return model_dictize.user_dictize(user, context)
def user_update(context, data_dict):
'''Updates the user\'s details'''
model = context['model']
user = context['user']
session = context['session']
schema = context.get('schema') or ckan.logic.schema.default_update_user_schema()
id = data_dict['id']
user_obj = model.User.get(id)
context['user_obj'] = user_obj
if user_obj is None:
raise NotFound('User was not found.')
check_access('user_update', context, data_dict)
data, errors = validate(data_dict, schema, context)
if errors:
session.rollback()
raise ValidationError(errors, error_summary(errors))
user = model_save.user_dict_save(data, context)
activity_dict = {
'user_id': user.id,
'object_id': user.id,
'activity_type': 'changed user',
}
activity_create_context = {
'model': model,
'user': user,
'defer_commit':True,
'session': session
}
get_action('activity_create')(activity_create_context, activity_dict, ignore_auth=True)
# TODO: Also create an activity detail recording what exactly changed in
# the user.
if not context.get('defer_commit'):
model.repo.commit()
return model_dictize.user_dictize(user, context)
def user_create(context, data_dict):
'''Creates a new user'''
model = context['model']
schema = context.get('schema') or ckan.logic.schema.default_user_schema()
session = context['session']
check_access('user_create', context, data_dict)
data, errors = validate(data_dict, schema, context)
if errors:
session.rollback()
raise ValidationError(errors, error_summary(errors))
user = model_save.user_dict_save(data, context)
# Flush the session to cause user.id to be initialised, because
# activity_create() (below) needs it.
session.flush()
activity_create_context = {
'model': model,
'user': context['user'],
'defer_commit': True,
'session': session
}
activity_dict = {
'user_id': user.id,
'object_id': user.id,
'activity_type': 'new user',
}
activity_create(activity_create_context, activity_dict, ignore_auth=True)
if not context.get('defer_commit'):
model.repo.commit()
context['user'] = user
context['id'] = user.id
log.debug('Created user %s' % str(user.name))
return model_dictize.user_dictize(user, context)
def user_create(context, data_dict):
'''Creates a new user'''
model = context['model']
schema = context.get('schema') or ckan.logic.schema.default_user_schema()
session = context['session']
check_access('user_create', context, data_dict)
data, errors = validate(data_dict, schema, context)
if errors:
session.rollback()
raise ValidationError(errors, error_summary(errors))
user = model_save.user_dict_save(data, context)
# Flush the session to cause user.id to be initialised, because
# activity_create() (below) needs it.
session.flush()
activity_create_context = {
'model': model,
'user': context['user'],
'defer_commit': True,
'session': session
}
activity_dict = {
'user_id': user.id,
'object_id': user.id,
'activity_type': 'new user',
}
activity_create(activity_create_context, activity_dict, ignore_auth=True)
if not context.get('defer_commit'):
model.repo.commit()
context['user'] = user
context['id'] = user.id
log.debug('Created user %s' % str(user.name))
return model_dictize.user_dictize(user, context)
def user_create(context, data_dict):
'''Creates a new user'''
model = context['model']
user = context['user']
schema = context.get('schema') or default_user_schema()
check_access('user_create', context, data_dict)
data, errors = validate(data_dict, schema, context)
if errors:
model.Session.rollback()
raise ValidationError(errors, group_error_summary(errors))
user = user_dict_save(data, context)
model.repo.commit()
context['user'] = user
context['id'] = user.id
log.debug('Created user %s' % str(user.name))
return user_dictize(user, context)
def user_create(context, data_dict):
'''Creates a new user'''
model = context['model']
user = context['user']
schema = context.get('schema') or default_user_schema()
check_access('user_create', context, data_dict)
data, errors = validate(data_dict, schema, context)
if errors:
model.Session.rollback()
raise ValidationError(errors, group_error_summary(errors))
user = user_dict_save(data, context)
if not context.get('defer_commit'):
model.repo.commit()
context['user'] = user
context['id'] = user.id
log.debug('Created user %s' % str(user.name))
return user_dictize(user, context)
def user_update(context, data_dict):
"""Updates the user's details"""
model = context["model"]
user = context["user"]
schema = context.get("schema") or default_update_user_schema()
id = data_dict["id"]
user_obj = model.User.get(id)
context["user_obj"] = user_obj
if user_obj is None:
raise NotFound("User was not found.")
check_access("user_update", context, data_dict)
data, errors = validate(data_dict, schema, context)
if errors:
model.Session.rollback()
raise ValidationError(errors, group_error_summary(errors))
user = user_dict_save(data, context)
model.repo.commit()
return user_dictize(user, context)
def user_update(context, data_dict):
'''Update a user account.
Normal users can only update their own user accounts. Sysadmins can update
any user account. Can not modify exisiting user's name.
For further parameters see
:py:func:`~ckan.logic.action.create.user_create`.
:param id: the name or id of the user to update
:type id: string
:returns: the updated user account
:rtype: dictionary
'''
model = context['model']
user = context['user']
session = context['session']
schema = context.get('schema') or schema_.default_update_user_schema()
id = _get_or_bust(data_dict, 'id')
user_obj = model.User.get(id)
context['user_obj'] = user_obj
if user_obj is None:
raise NotFound('User was not found.')
_check_access('user_update', context, data_dict)
data, errors = _validate(data_dict, schema, context)
if errors:
session.rollback()
raise ValidationError(errors)
# user schema prevents non-sysadmins from providing password_hash
if 'password_hash' in data:
data['_password'] = data.pop('password_hash')
user = model_save.user_dict_save(data, context)
# TODO: remove hack to update API Key in CAS database
log.info('Updating Api Key in CAS Database')
sql = 'UPDATE users SET apikey = %s WHERE username = %s'
conn = None
updated_rows = 0
try:
log.info('apikey = ' + data['apikey'])
log.info('username = '******'name'])
log.info('connecting to cas')
conn = psycopg2.connect(
"dbname=casino_ar_prod_users user=cas_default password=casPWnasaace"
)
cur = conn.cursor()
log.info('connected')
cur.execute(sql, (data['apikey'], data['name']))
updated_rows = cur.rowcount
conn.commit()
log.info('user apikey updated')
cur.close()
except (Exception, psycopg2.DatabaseError) as error:
log.error(error)
finally:
if conn is not None:
conn.close()
#end hack
activity_dict = {
'user_id': user.id,
'object_id': user.id,
'activity_type': 'changed user',
}
activity_create_context = {
'model': model,
'user': user,
'defer_commit': True,
'ignore_auth': True,
'session': session
}
_get_action('activity_create')(activity_create_context, activity_dict)
# TODO: Also create an activity detail recording what exactly changed in
# the user.
if not context.get('defer_commit'):
model.repo.commit()
return model_dictize.user_dictize(user, context)
def user_create(context, data_dict):
'''Create a new user.
You must be authorized to create users.
:param name: the name of the new user, a string between 2 and 100
characters in length, containing only lowercase alphanumeric
characters, ``-`` and ``_``
:type name: string
:param email: the email address for the new user
:type email: string
:param password: the password of the new user, a string of at least 4
characters
:type password: string
:param id: the id of the new user (optional)
:type id: string
:param fullname: the full name of the new user (optional)
:type fullname: string
:param about: a description of the new user (optional)
:type about: string
:param openid: (optional)
:type openid: string
:returns: the newly created yser
:rtype: dictionary
'''
model = context['model']
schema = context.get('schema') or ckan.logic.schema.default_user_schema()
session = context['session']
_check_access('user_create', context, data_dict)
data, errors = _validate(data_dict, schema, context)
if errors:
session.rollback()
raise ValidationError(errors)
user = model_save.user_dict_save(data, context)
# Flush the session to cause user.id to be initialised, because
# activity_create() (below) needs it.
session.flush()
activity_create_context = {
'model': model,
'user': context['user'],
'defer_commit': True,
'ignore_auth': True,
'session': session
}
activity_dict = {
'user_id': user.id,
'object_id': user.id,
'activity_type': 'new user',
}
logic.get_action('activity_create')(activity_create_context, activity_dict)
if not context.get('defer_commit'):
model.repo.commit()
# A new context is required for dictizing the newly constructed user in
# order that all the new user's data is returned, in particular, the
# api_key.
#
# The context is copied so as not to clobber the caller's context dict.
user_dictize_context = context.copy()
user_dictize_context['keep_sensitive_data'] = True
user_dict = model_dictize.user_dictize(user, user_dictize_context)
context['user_obj'] = user
context['id'] = user.id
model.Dashboard.get(user.id) # Create dashboard for user.
log.debug('Created user {name}'.format(name=user.name))
return user_dict
def user_create(context, data_dict):
'''Create a new user.
You must be authorized to create users.
:param name: the name of the new user, a string between 2 and 100
characters in length, containing only lowercase alphanumeric
characters, ``-`` and ``_``
:type name: string
:param email: the email address for the new user
:type email: string
:param password: the password of the new user, a string of at least 4
characters
:type password: string
:param id: the id of the new user (optional)
:type id: string
:param fullname: the full name of the new user (optional)
:type fullname: string
:param about: a description of the new user (optional)
:type about: string
:param openid: (optional)
:type openid: string
:returns: the newly created yser
:rtype: dictionary
'''
model = context['model']
schema = context.get('schema') or ckan.logic.schema.default_user_schema()
session = context['session']
_check_access('user_create', context, data_dict)
data, errors = _validate(data_dict, schema, context)
if errors:
session.rollback()
raise ValidationError(errors)
user = model_save.user_dict_save(data, context)
# Flush the session to cause user.id to be initialised, because
# activity_create() (below) needs it.
session.flush()
activity_create_context = {
'model': model,
'user': context['user'],
'defer_commit': True,
'session': session
}
activity_dict = {
'user_id': user.id,
'object_id': user.id,
'activity_type': 'new user',
}
logic.get_action('activity_create')(activity_create_context,
activity_dict, ignore_auth=True)
if not context.get('defer_commit'):
model.repo.commit()
# A new context is required for dictizing the newly constructed user in
# order that all the new user's data is returned, in particular, the
# api_key.
#
# The context is copied so as not to clobber the caller's context dict.
user_dictize_context = context.copy()
user_dictize_context['keep_sensitive_data'] = True
user_dict = model_dictize.user_dictize(user, user_dictize_context)
context['user_obj'] = user
context['id'] = user.id
log.debug('Created user %s' % str(user.name))
return user_dict
def user_update(context, data_dict):
'''Update a user account.
Normal users can only update their own user accounts. Sysadmins can update
any user account.
For further parameters see ``user_create()``.
:param id: the name or id of the user to update
:type id: string
:returns: the updated user account
:rtype: dictionary
'''
model = context['model']
user = context['user']
session = context['session']
schema = context.get('schema') or schema_.default_update_user_schema()
id = _get_or_bust(data_dict, 'id')
user_obj = model.User.get(id)
context['user_obj'] = user_obj
if user_obj is None:
raise NotFound('User was not found.')
_check_access('user_update', context, data_dict)
data, errors = _validate(data_dict, schema, context)
if errors:
session.rollback()
raise ValidationError(errors)
if (data_dict.get('current_password')):
if user_obj.validate_password(data_dict.get('current_password')):
log.info("El password anterior es OK. Puede procederse al cambio")
else:
raise ValidationError(
{'error': 'La contraseña actual no es '
'correcta'}
)
user = model_save.user_dict_save(data, context)
activity_dict = {
'user_id': user.id,
'object_id': user.id,
'activity_type': 'changed user',
}
activity_create_context = {
'model': model,
'user': user,
'defer_commit':True,
'session': session
}
_get_action('activity_create')(activity_create_context, activity_dict, ignore_auth=True)
# TODO: Also create an activity detail recording what exactly changed in
# the user.
if not context.get('defer_commit'):
model.repo.commit()
return model_dictize.user_dictize(user, context)
def user_update(context, data_dict):
'''Update a user account.
Normal users can only update their own user accounts. Sysadmins can update
any user account. Can not modify exisiting user's name.
.. note:: Update methods may delete parameters not explicitly provided in the
data_dict. If you want to edit only a specific attribute use `user_patch`
instead.
For further parameters see
:py:func:`~ckan.logic.action.create.user_create`.
:param id: the name or id of the user to update
:type id: string
:returns: the updated user account
:rtype: dictionary
'''
model = context['model']
user = author = context['user']
session = context['session']
schema = context.get('schema') or schema_.default_update_user_schema()
id = _get_or_bust(data_dict, 'id')
user_obj = model.User.get(id)
context['user_obj'] = user_obj
if user_obj is None:
raise NotFound('User was not found.')
_check_access('user_update', context, data_dict)
upload = uploader.get_uploader('user')
upload.update_data_dict(data_dict, 'image_url',
'image_upload', 'clear_upload')
data, errors = _validate(data_dict, schema, context)
if errors:
session.rollback()
raise ValidationError(errors)
# user schema prevents non-sysadmins from providing password_hash
if 'password_hash' in data:
data['_password'] = data.pop('password_hash')
user = model_save.user_dict_save(data, context)
activity_dict = {
'user_id': user.id,
'object_id': user.id,
'activity_type': 'changed user',
}
activity_create_context = {
'model': model,
'user': author,
'defer_commit': True,
'ignore_auth': True,
'session': session
}
_get_action('activity_create')(activity_create_context, activity_dict)
# TODO: Also create an activity detail recording what exactly changed in
# the user.
upload.upload(uploader.get_max_image_size())
if not context.get('defer_commit'):
model.repo.commit()
author_obj = model.User.get(context.get('user'))
include_plugin_extras = False
if author_obj:
include_plugin_extras = author_obj.sysadmin and 'plugin_extras' in data
user_dict = model_dictize.user_dictize(
user, context, include_plugin_extras=include_plugin_extras)
return user_dict
def user_update(context: Context, data_dict: DataDict) -> ActionResult.UserUpdate:
'''Update a user account.
Normal users can only update their own user accounts. Sysadmins can update
any user account. Can not modify exisiting user's name.
.. note:: Update methods may delete parameters not explicitly provided in the
data_dict. If you want to edit only a specific attribute use `user_patch`
instead.
For further parameters see
:py:func:`~ckan.logic.action.create.user_create`.
:param id: the name or id of the user to update
:type id: string
:returns: the updated user account
:rtype: dictionary
'''
model = context['model']
user = context['user']
session = context['session']
schema = context.get('schema') or schema_.default_update_user_schema()
id = _get_or_bust(data_dict, 'id')
user_obj = model.User.get(id)
if user_obj is None:
raise NotFound('User was not found.')
context['user_obj'] = user_obj
_check_access('user_update', context, data_dict)
upload = uploader.get_uploader('user')
upload.update_data_dict(data_dict, 'image_url',
'image_upload', 'clear_upload')
data, errors = _validate(data_dict, schema, context)
if errors:
session.rollback()
raise ValidationError(errors)
# user schema prevents non-sysadmins from providing password_hash
if 'password_hash' in data:
data['_password'] = data.pop('password_hash')
user = model_save.user_dict_save(data, context)
upload.upload(uploader.get_max_image_size())
if not context.get('defer_commit'):
with logic.guard_against_duplicated_email(data_dict['email']):
model.repo.commit()
author_obj = model.User.get(context.get('user'))
include_plugin_extras = False
if author_obj:
include_plugin_extras = author_obj.sysadmin and 'plugin_extras' in data
user_dict = model_dictize.user_dictize(
user, context, include_plugin_extras=include_plugin_extras)
return user_dict
def action_user_update(context, data_dict):
''' Modified from CKAN: user_update
Update a user account.
Normal users can only update their own user accounts. Sysadmins can update
any user account.
For further parameters see ``user_create()``.
:param id: the name or id of the user to update
:type id: string
:returns: the updated user account
:rtype: dictionary
'''
model = context['model']
user = context['user']
session = context['session']
schema = context.get('schema') or logic.schema.default_update_user_schema()
# Modify the schema by adding translation related keys
add_translation_modify_schema(schema)
upload = uploader.Upload('user')
upload.update_data_dict(data_dict, 'image_url', 'image_upload',
'clear_upload')
ignore_missing = toolkit.get_validator('ignore_missing')
convert_to_extras = toolkit.get_converter('convert_to_extras')
schema['job_title'] = [ignore_missing, unicode, convert_to_extras]
schema['telephone_number'] = [ignore_missing, unicode, convert_to_extras]
schema['main_organization'] = [ignore_missing, unicode, convert_to_extras]
schema['image_url'] = [ignore_missing, unicode, convert_to_extras]
schema['linkedin'] = [ignore_missing, unicode, convert_to_extras]
schema['facebook'] = [ignore_missing, unicode, convert_to_extras]
schema['twitter'] = [ignore_missing, unicode, convert_to_extras]
schema['blog'] = [ignore_missing, to_list_json, convert_to_extras]
schema['www_page'] = [ignore_missing, to_list_json, convert_to_extras]
# Add the localized keys for the localized fields to the schema
schema = add_languages_modify(schema, _localized_fields)
not_empty = toolkit.get_validator('not_empty')
schema['fullname'] = [not_empty, unicode]
id = logic.get_or_bust(data_dict, 'id')
user_obj = model.User.get(id)
context['user_obj'] = user_obj
if user_obj is None:
raise NotFound('User was not found.')
# If the translations are not in the data_dict, the user has not added any translations or the user has deleted all translations.
# Therefore, the translations are not sent with the POST so we need to empty and update the translations here.
if 'translations' not in data_dict:
data_dict['translations'] = []
toolkit.check_access('user_update', context, data_dict)
data, errors = validate(data_dict, schema, context)
if errors:
session.rollback()
raise ValidationError(errors)
for extra in data['extras'] if 'extras' in data else []:
user_obj.extras[extra['key']] = extra['value']
user = model_save.user_dict_save(data, context)
activity_dict = {
'user_id': user.id,
'object_id': user.id,
'activity_type': 'changed user'
}
activity_create_context = {
'model': model,
'user': user,
'defer_commit': True,
'ignore_auth': True,
'session': session
}
toolkit.get_action('activity_create')(activity_create_context,
activity_dict)
# Attempt to update drupal user
_update_drupal_user(context, data_dict)
# TODO: Also create an activity detail recording what exactly changed in
# the user.
upload.upload(uploader.get_max_image_size())
if not context.get('defer_commit'):
model.repo.commit()
user_data = user_dictize(user, context)
for key, value in user.extras.iteritems():
if key in user_data:
log.warning(
"Trying to override user data with extra variable '%s'", key)
continue
user_data[key] = value
return user_data
def user_create(context, data_dict):
'''Create a new user.
You must be authorized to create users.
:param name: the name of the new user, a string between 2 and 100
characters in length, containing only lowercase alphanumeric
characters, ``-`` and ``_``
:type name: string
:param email: the email address for the new user
:type email: string
:param password: the password of the new user, a string of at least 4
characters
:type password: string
:param id: the id of the new user (optional)
:type id: string
:param fullname: the full name of the new user (optional)
:type fullname: string
:param about: a description of the new user (optional)
:type about: string
:param openid: (optional)
:type openid: string
:returns: the newly created yser
:rtype: dictionary
'''
model = context['model']
schema = context.get('schema') or ckan.logic.schema.default_user_schema()
session = context['session']
_check_access('user_create', context, data_dict)
data, errors = _validate(data_dict, schema, context)
if errors:
session.rollback()
raise ValidationError(errors, _error_summary(errors))
user = model_save.user_dict_save(data, context)
# Flush the session to cause user.id to be initialised, because
# activity_create() (below) needs it.
session.flush()
activity_create_context = {
'model': model,
'user': context['user'],
'defer_commit': True,
'session': session
}
activity_dict = {
'user_id': user.id,
'object_id': user.id,
'activity_type': 'new user',
}
activity_create(activity_create_context, activity_dict, ignore_auth=True)
if not context.get('defer_commit'):
model.repo.commit()
context['user'] = user
context['id'] = user.id
log.debug('Created user %s' % str(user.name))
return model_dictize.user_dictize(user, context)
def user_create(context, data_dict):
"""Override default user_create action to proxy the user create to the wotkit.
This function unfortunately copy pastes from the original user_create function to add rollback if user creation fails on the wotkit.
First check if user exists on wotkit (raise validation error if they do)
Then it saves to ckan user table, then attempts to save to wotkit. If they both are successful the change is saved to ckan user table.
"""
# Temporarily defer commits so we can reuse code and rollback if wotkit problems
prev_defer_commit = context.get("defer_commit")
context["defer_commit"] = True
session = context['session']
# Call parent method, this should handle authorization and rollback on error
model = context['model']
schema = context.get('schema') or ckan.logic.schema.default_user_schema()
_check_access('user_create', context, data_dict)
data, errors = _validate(data_dict, schema, context)
if errors:
session.rollback()
raise ValidationError(errors)
user = model_save.user_dict_save(data, context)
wotkit_proxy = config_globals.get_wotkit_proxy()
if wotkit_proxy.get_wotkit_user(user.name):
session.rollback()
raise logic.ValidationError({"User already exists in wotkit": " "})
data = {"username": user.name,
"password": user.password1,
"email": user.email,
"firstname": user.fullname,
"lastname": " ",
"timeZone": data_dict["timezone"]}
try:
# custom validation
_validate_user_data(user)
wotkit_proxy.create_wotkit_user(data)
log.debug("Success creating wotkit account")
except Exception as e:
log.debug("Failed creating wotkit account")
session.rollback()
raise logic.ValidationError({"Failed user creation in wotkit. Error: " + str(e): " "})
# Flush the session to cause user.id to be initialised, because
# activity_create() (below) needs it.
session.flush()
activity_create_context = {
'model': model,
'user': context['user'],
'defer_commit': True,
'ignore_auth': True,
'session': session
}
activity_dict = {
'user_id': user.id,
'object_id': user.id,
'activity_type': 'new user',
}
#logic.get_action('activity_create')(activity_create_context,
# activity_dict, ignore_auth=True)
logic.get_action('activity_create')(activity_create_context,activity_dict)
if not context.get('defer_commit'):
model.repo.commit()
# A new context is required for dictizing the newly constructed user in
# order that all the new user's data is returned, in particular, the
# api_key.
#
# The context is copied so as not to clobber the caller's context dict.
user_dictize_context = context.copy()
user_dictize_context['keep_sensitive_data'] = True
#user_dictize_context['keep_apikey'] = True
#user_dictize_context['keep_email'] = True
user_dict = model_dictize.user_dictize(user, user_dictize_context)
context['user_obj'] = user
context['id'] = user.id
model.Dashboard.get(user.id) # Create dashboard for user.
log.debug('Created user {name}'.format(name=user.name))
#wotkit_create_dict = {"ckan_id": user_model.id,
# "wotkit_id": data_dict["wotkit_id"],
# "wotkit_password": data_dict["wotkit_password"]}
#ckan.lib.dictization.table_dict_save(wotkit_create_dict, WotkitUser, context)
if not prev_defer_commit:
model.repo.commit()
context["defer_commit"] = prev_defer_commit
return user_dict
def user_create(context, data_dict):
"""Create a new user.
You must be authorized to create users.
:param name: the name of the new user, a string between 2 and 100
characters in length, containing only lowercase alphanumeric
characters, ``-`` and ``_``
:type name: string
:param email: the email address for the new user
:type email: string
:param password: the password of the new user, a string of at least 4
characters
:type password: string
:param id: the id of the new user (optional)
:type id: string
:param fullname: the full name of the new user (optional)
:type fullname: string
:param about: a description of the new user (optional)
:type about: string
:param openid: (optional)
:type openid: string
:returns: the newly created yser
:rtype: dictionary
"""
model = context["model"]
schema = context.get("schema") or ckan.logic.schema.default_user_schema()
session = context["session"]
_check_access("user_create", context, data_dict)
data, errors = _validate(data_dict, schema, context)
if errors:
session.rollback()
raise ValidationError(errors)
user = model_save.user_dict_save(data, context)
# Flush the session to cause user.id to be initialised, because
# activity_create() (below) needs it.
session.flush()
activity_create_context = {
"model": model,
"user": context["user"],
"defer_commit": True,
"ignore_auth": True,
"session": session,
}
activity_dict = {"user_id": user.id, "object_id": user.id, "activity_type": "new user"}
logic.get_action("activity_create")(activity_create_context, activity_dict)
if not context.get("defer_commit"):
model.repo.commit()
# A new context is required for dictizing the newly constructed user in
# order that all the new user's data is returned, in particular, the
# api_key.
#
# The context is copied so as not to clobber the caller's context dict.
user_dictize_context = context.copy()
user_dictize_context["keep_apikey"] = True
user_dictize_context["keep_email"] = True
user_dict = model_dictize.user_dictize(user, user_dictize_context)
context["user_obj"] = user
context["id"] = user.id
model.Dashboard.get(user.id) # Create dashboard for user.
log.debug("Created user {name}".format(name=user.name))
return user_dict
def action_user_update(context, data_dict):
''' Modified from CKAN: user_update
Update a user account.
Normal users can only update their own user accounts. Sysadmins can update
any user account.
For further parameters see ``user_create()``.
:param id: the name or id of the user to update
:type id: string
:returns: the updated user account
:rtype: dictionary
'''
model = context['model']
user = context['user']
session = context['session']
schema = context.get('schema') or logic.schema.default_update_user_schema()
# Modify the schema by adding translation related keys
add_translation_modify_schema(schema)
upload = uploader.Upload('user')
upload.update_data_dict(data_dict, 'image_url', 'image_upload', 'clear_upload')
ignore_missing = toolkit.get_validator('ignore_missing')
convert_to_extras = toolkit.get_converter('convert_to_extras')
schema['job_title'] = [ignore_missing, unicode, convert_to_extras]
schema['telephone_number'] = [ignore_missing, unicode, convert_to_extras]
schema['main_organization'] = [ignore_missing, unicode, convert_to_extras]
schema['image_url'] = [ignore_missing, unicode, convert_to_extras]
schema['linkedin'] = [ignore_missing, unicode, convert_to_extras]
schema['facebook'] = [ignore_missing, unicode, convert_to_extras]
schema['twitter'] = [ignore_missing, unicode, convert_to_extras]
schema['blog'] = [ignore_missing, to_list_json, convert_to_extras]
schema['www_page'] = [ignore_missing, to_list_json, convert_to_extras]
# Add the localized keys for the localized fields to the schema
schema = add_languages_modify(schema, _localized_fields)
not_empty = toolkit.get_validator('not_empty')
schema['fullname'] = [not_empty, unicode]
id = logic.get_or_bust(data_dict, 'id')
user_obj = model.User.get(id)
context['user_obj'] = user_obj
if user_obj is None:
raise NotFound('User was not found.')
# If the translations are not in the data_dict, the user has not added any translations or the user has deleted all translations.
# Therefore, the translations are not sent with the POST so we need to empty and update the translations here.
if 'translations' not in data_dict:
data_dict['translations'] = []
toolkit.check_access('user_update', context, data_dict)
data, errors = validate(data_dict, schema, context)
if errors:
session.rollback()
raise ValidationError(errors)
for extra in data['extras'] if 'extras' in data else []:
user_obj.extras[extra['key']] = extra['value']
user = model_save.user_dict_save(data, context)
activity_dict = {'user_id': user.id,
'object_id': user.id,
'activity_type': 'changed user'}
activity_create_context = {'model': model,
'user': user,
'defer_commit': True,
'ignore_auth': True,
'session': session}
toolkit.get_action('activity_create')(activity_create_context, activity_dict)
# Attempt to update drupal user
_update_drupal_user(context, data_dict)
# TODO: Also create an activity detail recording what exactly changed in
# the user.
upload.upload(uploader.get_max_image_size())
if not context.get('defer_commit'):
model.repo.commit()
user_data = user_dictize(user, context)
for key, value in user.extras.iteritems():
if key in user_data:
log.warning("Trying to override user data with extra variable '%s'", key)
continue
user_data[key] = value
return user_data
def user_update(context, data_dict):
'''Update a user account.
Normal users can only update their own user accounts. Sysadmins can update
any user account. Can not modify exisiting user's name.
For further parameters see
:py:func:`~ckan.logic.action.create.user_create`.
:param id: the name or id of the user to update
:type id: string
:returns: the updated user account
:rtype: dictionary
'''
model = context['model']
session = context['session']
schema = context.get('schema') or default_update_user_schema()
id = _get_or_bust(data_dict, 'id')
data_dict['user-terms-agree'] = toolkit.request.form.get("user-terms-agree")
data_dict['uploader-terms-agree'] = toolkit.request.form.get(
"uploader-terms-agree")
data_dict['allow_marketting_emails'] = toolkit.request.form.get(
"allow_marketting_emails")
user_obj = model.User.get(id)
context['user_obj'] = user_obj
if user_obj is None:
raise NotFound('User was not found.')
_check_access('user_update', context, data_dict)
data, errors = _validate(data_dict, schema, context)
if errors:
session.rollback()
raise ValidationError(errors)
# user state of "pending" is the user who doesn't yet have access to the
# site and must reset their password to do so.
if user_obj.state == u'pending' and not (
data['user-terms-agree'] and data['uploader-terms-agree']
):
session.rollback()
raise ValueError(toolkit._("You must agree to the Terms and "
"Conditions and Uploader Agreement"))
# user schema prevents non-sysadmins from providing password_hash
if 'password_hash' in data:
data['_password'] = data.pop('password_hash')
user = model_save.user_dict_save(data, context)
user_marsavin = user_marsavin_save(data, context)
try:
if data["allow_marketting_emails"]:
toolkit.enqueue_job(subscribe_to_mailchimp, [user_obj])
except KeyError:
pass
activity_dict = {
'user_id': user.id,
'object_id': user.id,
'activity_type': 'changed user',
}
activity_create_context = {
'model': model,
'user': user,
'defer_commit': True,
'ignore_auth': True,
'session': session
}
_get_action('activity_create')(activity_create_context, activity_dict)
# TODO: Also create an activity detail recording what exactly changed in
# the user.
if not context.get('defer_commit'):
model.repo.commit()
return model_dictize.user_dictize(user, context)
