def test_2_group_schema(self):
group = model.Session.query(model.Group).first()
data = group_dictize(group, self.context)
converted_data, errors = validate(data, default_group_schema(), self.context)
group_pack = sorted(group.packages, key=lambda x:x.id)
converted_data["packages"] = sorted(converted_data["packages"], key=lambda x:x["id"])
expected = {'description': u'These are books that David likes.',
'id': group.id,
'name': u'david',
'packages': sorted([{'id': group_pack[0].id},
{'id': group_pack[1].id,
}], key=lambda x:x["id"]),
'title': u"Dave's books"}
assert not errors
assert converted_data == expected, pformat(converted_data) + '\n\n' + pformat(expected)
data["packages"].sort(key=lambda x:x["id"])
data["packages"][0]["id"] = 'fjdlksajfalsf'
data["packages"][1].pop("id")
data["packages"][1].pop("name")
converted_data, errors = validate(data, default_group_schema(), self.context)
assert errors == {'packages': [{'id': [u'Dataset was not found.']}, {'id': [u'Missing value']}]} , pformat(errors)
def test_2_group_schema(self):
context = {"model": model, "session": model.Session}
group = model.Session.query(model.Group).first()
data = group_dictize(group, context)
converted_data, errors = validate(data, default_group_schema(), context)
group_pack = sorted(group.packages, key=lambda x: x.id)
converted_data["packages"] = sorted(converted_data["packages"], key=lambda x: x["id"])
expected = {
"description": u"These are books that David likes.",
"id": group.id,
"name": u"david",
"packages": sorted([{"id": group_pack[0].id}, {"id": group_pack[1].id}], key=lambda x: x["id"]),
"title": u"Dave's books",
}
assert not errors
assert converted_data == expected, pformat(converted_data) + "\n\n" + pformat(expected)
data["packages"].sort(key=lambda x: x["id"])
data["packages"][0]["id"] = "fjdlksajfalsf"
data["packages"][1].pop("id")
data["packages"][1].pop("name")
converted_data, errors = validate(data, default_group_schema(), context)
assert errors == {"packages": [{"id": [u"Dataset was not found."]}, {"id": [u"Missing value"]}]}, pformat(
errors
)
def test_2_group_schema(self):
group = model.Session.query(model.Group).first()
data = group_dictize(group, self.context)
# we don't want these here
del data['groups']
del data['users']
del data['tags']
del data['extras']
converted_data, errors = validate(data,
default_group_schema(),
self.context)
group_pack = sorted(group.packages(), key=lambda x: x.id)
converted_data["packages"] = sorted(converted_data["packages"],
key=lambda x: x["id"])
expected = {
'description': u'These are books that David likes.',
'id': group.id,
'name': u'david',
'is_organization': False,
'type': u'group',
'image_url': u'',
'image_display_url': u'',
'packages': sorted([{'id': group_pack[0].id,
'name': group_pack[0].name,
'title': group_pack[0].title},
{'id': group_pack[1].id,
'name': group_pack[1].name,
'title':group_pack[1].title}],
key=lambda x: x["id"]),
'title': u"Dave's books",
'approval_status': u'approved'
}
assert not errors
assert converted_data == expected, pformat(converted_data)
data["packages"].sort(key=lambda x: x["id"])
data["packages"][0]["id"] = 'fjdlksajfalsf'
data["packages"][1].pop("id")
data["packages"][1].pop("name")
converted_data, errors = validate(data,
default_group_schema(),
self.context)
assert errors == {
'packages': [{'id': [u'Not found: Dataset']},
{'id': [u'Missing value']}]
}, pformat(errors)
def test_2_group_schema(self):
group = model.Session.query(model.Group).first()
data = group_dictize(group, self.context)
# we don't want these here
del data['groups']
del data['users']
del data['tags']
del data['extras']
converted_data, errors = validate(data,
default_group_schema(),
self.context)
group_pack = sorted(group.packages(), key=lambda x: x.id)
converted_data["packages"] = sorted(converted_data["packages"],
key=lambda x: x["id"])
expected = {
'description': u'These are books that David likes.',
'id': group.id,
'name': u'david',
'is_organization': False,
'type': u'group',
'image_url': u'',
'image_display_url': u'',
'packages': sorted([{'id': group_pack[0].id,
'name': group_pack[0].name,
'title': group_pack[0].title},
{'id': group_pack[1].id,
'name': group_pack[1].name,
'title':group_pack[1].title}],
key=lambda x: x["id"]),
'title': u"Dave's books",
'approval_status': u'approved'
}
assert not errors
assert converted_data == expected, pformat(converted_data)
data["packages"].sort(key=lambda x: x["id"])
data["packages"][0]["id"] = 'fjdlksajfalsf'
data["packages"][1].pop("id")
data["packages"][1].pop("name")
converted_data, errors = validate(data,
default_group_schema(),
self.context)
assert errors == {
'packages': [{'id': [u'Not found: Dataset']},
{'id': [u'Missing value']}]
}, pformat(errors)
def test_2_group_schema(self):
context = {'model': model, 'session': model.Session}
group = model.Session.query(model.Group).first()
data = group_dictize(group, context)
converted_data, errors = validate(data, default_group_schema(),
context)
group_pack = sorted(group.packages, key=lambda x: x.id)
converted_data["packages"] = sorted(converted_data["packages"],
key=lambda x: x["id"])
expected = {
'description':
u'These are books that David likes.',
'id':
group.id,
'name':
u'david',
'packages':
sorted([{
'id': group_pack[0].id
}, {
'id': group_pack[1].id,
}],
key=lambda x: x["id"]),
'title':
u"Dave's books"
}
assert not errors
assert converted_data == expected, pformat(
converted_data) + '\n\n' + pformat(expected)
data["packages"].sort(key=lambda x: x["id"])
data["packages"][0]["id"] = 'fjdlksajfalsf'
data["packages"][1].pop("id")
data["packages"][1].pop("name")
converted_data, errors = validate(data, default_group_schema(),
context)
assert errors == {
'packages': [{
'id': [u'Package was not found.']
}, {
'id': [u'Missing value']
}]
}, pformat(errors)
def group_create(context, data_dict):
model = context['model']
user = context['user']
schema = context.get('schema') or default_group_schema()
check_access(model.System(), model.Action.GROUP_CREATE, context)
data, errors = validate(data_dict, schema, context)
if errors:
model.Session.rollback()
raise ValidationError(errors, group_error_summary(errors))
rev = model.repo.new_revision()
rev.author = user
if 'message' in context:
rev.message = context['message']
else:
rev.message = _(u'REST API: Create object %s') % data.get("name")
group = group_dict_save(data, context)
if user:
admins = [model.User.by_name(user.decode('utf8'))]
else:
admins = []
model.setup_default_user_roles(group, admins)
for item in PluginImplementations(IGroupController):
item.create(group)
model.repo.commit()
context["group"] = group
context["id"] = group.id
log.debug('Created object %s' % str(group.name))
return group_dictize(group, context)
def setup(self):
super(TestProjectBase, self).setup()
self.user = factories.User()
context = {
'model': model,
'session': model.Session,
'user': self.user['name'],
}
org_create_context = context.copy()
org_create_context['schema'] = schema.default_group_schema()
self.organization = helpers.call_action('organization_create',
context=context,
id='1',
name='organization')
project_context = context.copy()
project_context['schema'] = schema.default_create_package_schema()
self.project = helpers.call_action(
'package_create',
context=project_context,
type='project',
id='1',
name='test',
title='Test',
owner_org=self.organization['name'],
)
def group_create(context, data_dict):
model = context['model']
user = context['user']
schema = context.get('schema') or default_group_schema()
check_access(model.System(), model.Action.GROUP_CREATE, context)
data, errors = validate(data_dict, schema, context)
if errors:
model.Session.rollback()
raise ValidationError(errors, group_error_summary(errors))
rev = model.repo.new_revision()
rev.author = user
if 'message' in context:
rev.message = context['message']
else:
rev.message = _(u'REST API: Create object %s') % data.get("name")
group = group_dict_save(data, context)
if user:
admins = [model.User.by_name(user.decode('utf8'))]
else:
admins = []
model.setup_default_user_roles(group, admins)
for item in PluginImplementations(IGroupController):
item.create(group)
model.repo.commit()
context["group"] = group
context["id"] = group.id
log.debug('Created object %s' % str(group.name))
return group_dictize(group, context)
def show_group_schema():
boolean_validator = get_validator('boolean_validator')
not_missing = get_validator('not_missing')
convert_from_extras = get_converter('convert_from_extras')
schema = default_group_schema()
schema.update({'needs_approval': [not_missing, boolean_validator, convert_from_extras]})
return schema
def setup(self):
super(TestProjectBase, self).setup()
self.user = factories.User()
context = {
'model': model,
'session': model.Session,
'user': self.user['name'],
}
org_create_context = context.copy()
org_create_context['schema'] = schema.default_group_schema()
self.organization = helpers.call_action(
'organization_create',
context=context,
id='1',
name='organization'
)
project_context = context.copy()
project_context['schema'] = schema.default_create_package_schema()
self.project = helpers.call_action(
'package_create',
context=project_context,
type='project',
id='1',
name='test',
title='Test',
owner_org=self.organization['name'],
)
def _add_users( self, group, parameters ):
if not group:
h.flash_error(_("There was a problem with your submission, "
"please correct it and try again"))
errors = {"reason": ["No reason was supplied"]}
return self.apply(group.id, errors=errors,
error_summary=action.error_summary(errors))
data_dict = logic.clean_dict(dict_func.unflatten(
logic.tuplize_dict(logic.parse_params(request.params))))
data_dict['id'] = group.id
# Temporary fix for strange caching during dev
l = data_dict['users']
for d in l:
d['capacity'] = d.get('capacity','editor')
context = {
"group" : group,
"schema": schema.default_group_schema(),
"model": model,
"session": model.Session
}
# Temporary cleanup of a capacity being sent without a name
users = [d for d in data_dict['users'] if len(d) == 2]
data_dict['users'] = users
model.repo.new_revision()
model_save.group_member_save(context, data_dict, 'users')
model.Session.commit()
h.redirect_to( controller='group', action='edit', id=group.name)
def test_2_group_schema(self):
group = model.Session.query(model.Group).first()
data = group_dictize(group, self.context)
# we don't want these here
del data["groups"]
del data["users"]
del data["tags"]
del data["extras"]
converted_data, errors = validate(data, default_group_schema(), self.context)
group_pack = sorted(group.packages(), key=lambda x: x.id)
converted_data["packages"] = sorted(converted_data["packages"], key=lambda x: x["id"])
expected = {
"description": u"These are books that David likes.",
"id": group.id,
"name": u"david",
"is_organization": False,
"type": u"group",
"image_url": u"",
"packages": sorted(
[
{"id": group_pack[0].id, "name": group_pack[0].name, "title": group_pack[0].title},
{"id": group_pack[1].id, "name": group_pack[1].name, "title": group_pack[1].title},
],
key=lambda x: x["id"],
),
"title": u"Dave's books",
"approval_status": u"approved",
}
assert not errors
assert converted_data == expected, pformat(converted_data)
data["packages"].sort(key=lambda x: x["id"])
data["packages"][0]["id"] = "fjdlksajfalsf"
data["packages"][1].pop("id")
data["packages"][1].pop("name")
converted_data, errors = validate(data, default_group_schema(), self.context)
assert errors == {"packages": [{"id": [u"Not found: Dataset"]}, {"id": [u"Missing value"]}]}, pformat(errors)
def db_to_form_schema(self, group_type=None):
packages_schema = project_schema.project_show_schema()
packages_schema.pop('organization', '')
schema = default_group_schema()
schema.update({
'orgURL': [convert_from_extras, ignore_missing, unicode],
'contact': [convert_from_extras, ignore_missing, unicode],
'cadasta_id': [convert_from_extras, ignore_missing, unicode],
'packages': packages_schema,
})
return schema
def db_to_form_schema_options(self, options):
# Get the default organization schema
schema = super(SchemaPlugin, self).db_to_form_schema_options(options)
if not schema:
from ckan.logic.schema import default_group_schema
schema = default_group_schema()
# Add custom fileds to organization schema
schema.update({'private': [cnvrt_from_ext, ignore_missing, unicode]})
return schema
def create_group_schema():
boolean_validator = get_validator('boolean_validator')
not_missing = get_validator('not_missing')
convert_to_extras = get_converter('convert_to_extras')
name_validator = get_validator('name_validator')
group_name_validator = get_validator('group_name_validator')
schema = default_group_schema()
schema.update({
'name': [not_empty, unicode, name_validator, group_name_validator,
no_pending_organization_with_same_name],
'needs_approval': [not_missing, boolean_validator, convert_to_extras]
})
return schema
def db_to_form_schema_options(self, options):
#Get the default organization schema
schema = super(HierarchyForm, self).db_to_form_schema_options(options)
if not schema :
from ckan.logic.schema import default_group_schema
schema = default_group_schema()
#Add custom fileds to organization schema
schema.update({
'url' : [cnvrt_from_ext, ignore_missing, unicode],
'sector' : [cnvrt_from_ext, ignore_missing, unicode]
})
return schema
def db_to_form_schema(data, package_type=None):
from ckan.logic.schema import default_group_schema
schema = {
'foi-name' : [convert_from_extras, ignore_missing, unicode],
'foi-email': [convert_from_extras, ignore_missing, unicode],
'foi-phone': [convert_from_extras, ignore_missing, unicode],
'contact-name' : [convert_from_extras, ignore_missing, unicode],
'contact-email': [convert_from_extras, ignore_missing, unicode],
'contact-phone': [convert_from_extras, ignore_missing, unicode],
'category': [convert_from_extras],
'abbreviation': [convert_from_extras, ignore_missing, unicode],
}
schema.update( default_group_schema() )
return schema
def show_group_schema():
boolean_validator = get_validator('boolean_validator')
convert_from_extras = get_converter('convert_from_extras')
schema = default_group_schema()
schema.update({
'needs_approval': [convert_from_extras, ignore_missing, boolean_validator],
'num_followers': [ignore_missing],
'package_count': [ignore_missing],
'display_name': [ignore_missing]
})
schema['packages'].update({
'notes': [ignore_missing],
})
return schema
def db_to_form_schema(data, package_type=None):
from ckan.logic.schema import default_group_schema
schema = {
'foi-name': [convert_from_extras, ignore_missing, unicode],
'foi-email': [convert_from_extras, ignore_missing, unicode],
'foi-phone': [convert_from_extras, ignore_missing, unicode],
'contact-name': [convert_from_extras, ignore_missing, unicode],
'contact-email': [convert_from_extras, ignore_missing, unicode],
'contact-phone': [convert_from_extras, ignore_missing, unicode],
'category': [convert_from_extras],
'abbreviation': [convert_from_extras, ignore_missing, unicode],
}
schema.update(default_group_schema())
return schema
def db_to_form_schema(data, package_type=None):
from ckan.logic.schema import default_group_schema
schema = {
'foi-name' : [convert_from_extras, ignore_missing, unicode],
'foi-email': [convert_from_extras, ignore_missing, unicode],
'foi-phone': [convert_from_extras, ignore_missing, unicode],
'foi-web': [convert_from_extras, ignore_missing, unicode],
'contact-name' : [convert_from_extras, ignore_missing, unicode],
'contact-email': [convert_from_extras, ignore_missing, unicode],
'contact-phone': [convert_from_extras, ignore_missing, unicode],
'category': [convert_from_extras, ignore_missing],
'abbreviation': [convert_from_extras, ignore_missing, unicode],
'closed': [convert_from_extras, ignore_missing, dgu_boolean_validator],
'replaced_by': [convert_from_extras, value_if_missing([]), from_json],
}
schema.update( default_group_schema() )
return schema
def _add_users(self, group, parameters):
from ckan.logic.schema import default_group_schema
from ckan.logic.action import error_summary
from ckan.lib.dictization.model_save import group_member_save
if not group:
h.flash_error(_("There was a problem with your submission, \
please correct it and try again"))
errors = {"reason": ["No reason was supplied"]}
return self.apply(group.id, errors=errors,
error_summary=error_summary(errors))
data_dict = clean_dict(unflatten(
tuplize_dict(parse_params(request.params))))
data_dict['id'] = group.id
# Temporary fix for strange caching during dev
l = data_dict['users']
for d in l:
# Form javascript creates d['capacity'] == 'undefined' for
# newly added users.
# If javascript in users form is not working (such as in tests)
# it will not create a capacity value.
if 'capacity' not in d or d['capacity'] == 'undefined':
# default to 'editor'
d['capacity'] = 'editor'
context = {
"group" : group,
"schema": default_group_schema(),
"model": model,
"session": model.Session
}
# Temporary cleanup of a capacity being sent without a name
users = [d for d in data_dict['users'] if len(d) == 2]
data_dict['users'] = users
model.repo.new_revision()
group_member_save(context, data_dict, 'users')
model.Session.commit()
h.redirect_to('/publisher/%s' % str(group.name))
def group_form_schema():
schema = ckan_schema.default_group_schema()
schema['description'] = [
ignore_missing, unicode, validators.description_length_validator
]
schema['packages'] = {
"name": [not_empty, unicode],
"title": [ignore_missing],
"__extras": [ignore]
}
schema['users'] = {
"name": [not_empty, unicode],
"capacity": [ignore_missing],
"__extras": [ignore]
}
schema['num_followers'] = []
schema['package_count'] = [ignore_missing]
return schema
def _add_users(self, group, parameters):
if not group:
h.flash_error(
_("There was a problem with your submission, "
"please correct it and try again"))
errors = {"reason": ["No reason was supplied"]}
return self.apply(group.id,
errors=errors,
error_summary=action.error_summary(errors))
data_dict = logic.clean_dict(
dict_func.unflatten(
logic.tuplize_dict(logic.parse_params(request.params))))
data_dict['id'] = group.id
# Temporary fix for strange caching during dev
l = data_dict['users']
for d in l:
d['capacity'] = d.get('capacity', 'editor')
context = {
"group": group,
"schema": schema.default_group_schema(),
"model": model,
"session": model.Session
}
# Temporary cleanup of a capacity being sent without a name
users = [d for d in data_dict['users'] if len(d) == 2]
data_dict['users'] = users
model.repo.new_revision()
model_save.group_member_save(context, data_dict, 'users')
model.Session.commit()
h.redirect_to(controller='group', action='edit', id=group.name)
def db_to_form_schema(self, package_type=None):
from ckan.logic.schema import default_group_schema
schema = default_group_schema()
for optional_extra in [
'category', 'contact-name', 'contact-email', 'contact-phone',
'foi-name', 'foi-email', 'foi-web', 'foi-phone'
]:
schema.update({
optional_extra: [
toolkit.get_converter('convert_from_extras'),
toolkit.get_validator('ignore_missing'), unicode
]
})
schema['num_followers'] = []
schema['created'] = []
schema['display_name'] = []
schema['package_count'] = [toolkit.get_validator('ignore_missing')]
schema['packages'] = {
'__extras': [toolkit.get_validator('keep_extras')]
}
schema['revision_id'] = []
schema['state'] = []
schema['users'] = {'__extras': [toolkit.get_validator('keep_extras')]}
return schema
def group_create(context, data_dict):
model = context['model']
user = context['user']
session = context['session']
schema = context.get('schema') or default_group_schema()
parent = context.get('parent', None)
check_access('group_create',context,data_dict)
data, errors = validate(data_dict, schema, context)
if errors:
session.rollback()
raise ValidationError(errors, group_error_summary(errors))
rev = model.repo.new_revision()
rev.author = user
if 'message' in context:
rev.message = context['message']
else:
rev.message = _(u'REST API: Create object %s') % data.get("name")
group = group_dict_save(data, context)
if parent:
parent_group = model.Group.get( parent )
if parent_group:
member = model.Member(group=parent_group, table_id=group.id, table_name='group')
session.add(member)
if user:
admins = [model.User.by_name(user.decode('utf8'))]
else:
admins = []
model.setup_default_user_roles(group, admins)
# Needed to let extensions know the group id
session.flush()
for item in PluginImplementations(IGroupController):
item.create(group)
activity_dict = {
'user_id': model.User.by_name(user.decode('utf8')).id,
'object_id': group.id,
'activity_type': 'new group',
}
activity_dict['data'] = {
'group': ckan.lib.dictization.table_dictize(group, context)
}
activity_create_context = {
'model': model,
'user': user,
'defer_commit':True,
'session': session
}
activity_create(activity_create_context, activity_dict, ignore_auth=True)
if not context.get('defer_commit'):
model.repo.commit()
context["group"] = group
context["id"] = group.id
log.debug('Created object %s' % str(group.name))
return group_dictize(group, context)
def test_group_schema(self):
group = factories.Group.model()
context = {"model": model, "session": model.Session}
factories.Dataset.create_batch(2, groups=[{"name": group.name}])
data = group_dictize(group, context)
# we don't want these here
del data["groups"]
del data["users"]
del data["tags"]
del data["extras"]
converted_data, errors = validate(
data, default_group_schema(), context
)
assert not errors
group_pack = sorted(group.packages(), key=operator.attrgetter("id"))
converted_data["packages"] = sorted(
converted_data["packages"], key=operator.itemgetter("id")
)
expected = {
"description": group.description,
"id": group.id,
"name": group.name,
"is_organization": False,
"type": u"group",
"image_url": group.image_url,
"image_display_url": group.image_url,
"packages": sorted(
[
{
"id": group_pack[0].id,
"name": group_pack[0].name,
"title": group_pack[0].title,
},
{
"id": group_pack[1].id,
"name": group_pack[1].name,
"title": group_pack[1].title,
},
],
key=operator.itemgetter("id"),
),
"title": group.title,
"approval_status": u"approved",
}
assert converted_data == expected, pformat(converted_data)
data["packages"].sort(key=lambda x: x["id"])
data["packages"][0]["id"] = factories.Dataset.stub().name
data["packages"][1].pop("id")
data["packages"][1].pop("name")
converted_data, errors = validate(
data, default_group_schema(), context
)
assert errors == {
"packages": [
{"id": [u"Not found: Dataset"]},
{"id": [u"Missing value"]},
]
}, pformat(errors)
def test_2_group_schema(self):
group = model.Session.query(model.Group).first()
data = group_dictize(group, self.context)
# we don't want these here
del data["groups"]
del data["users"]
del data["tags"]
del data["extras"]
converted_data, errors = validate(
data, default_group_schema(), self.context
)
group_pack = sorted(group.packages(), key=lambda x: x.id)
converted_data["packages"] = sorted(
converted_data["packages"], key=lambda x: x["id"]
)
expected = {
"description": u"These are books that David likes.",
"id": group.id,
"name": u"david",
"is_organization": False,
"type": u"group",
"image_url": u"",
"image_display_url": u"",
"packages": sorted(
[
{
"id": group_pack[0].id,
"name": group_pack[0].name,
"title": group_pack[0].title,
},
{
"id": group_pack[1].id,
"name": group_pack[1].name,
"title": group_pack[1].title,
},
],
key=lambda x: x["id"],
),
"title": u"Dave's books",
"approval_status": u"approved",
}
assert not errors
assert converted_data == expected, pformat(converted_data)
data["packages"].sort(key=lambda x: x["id"])
data["packages"][0]["id"] = "fjdlksajfalsf"
data["packages"][1].pop("id")
data["packages"][1].pop("name")
converted_data, errors = validate(
data, default_group_schema(), self.context
)
assert errors == {
"packages": [
{"id": [u"Not found: Dataset"]},
{"id": [u"Missing value"]},
]
}, pformat(errors)
def _add_users(self, group, parameters):
from ckan.logic.schema import default_group_schema
from ckan.logic.action import error_summary
from ckan.lib.dictization.model_save import group_member_save
if not group:
h.flash_error(
_("There was a problem with your submission, \
please correct it and try again"))
errors = {"reason": ["No reason was supplied"]}
return self.users(group.name,
errors=errors,
error_summary=error_summary(errors))
data_dict = clean_dict(
unflatten(tuplize_dict(parse_params(request.params))))
data_dict['id'] = group.id
# Check that the user being added, if they are a Drupal user, has
# verified their email address
new_users = [user['name'] for user in data_dict['users'] \
if not 'capacity' in user or user['capacity'] == 'undefined']
# Removed Drupal auth stuff.
# for user_name in new_users:
# drupal_id = DrupalUserMapping.ckan_user_name_to_drupal_id(user_name)
# if drupal_id:
# if not is_drupal_auth_activated():
# # joint auth with Drupal is not activated, so cannot
# # check with Drupal
# log.warning('Drupal user made editor/admin but without checking email is verified.')
# break
# if 'drupal_client' not in dir(self):
# self.drupal_client = DrupalClient()
# user_properties = self.drupal_client.get_user_properties(drupal_id)
# roles = user_properties['roles'].values()
# if 'unverified user' in roles:
# user = model.User.by_name(user_name)
# h.flash_error("There was a problem with your submission - see the error message below.")
# errors = {"reason": ['User "%s" has not verified their email address yet. '
# 'Please ask them to do this and then try again. ' % \
# user.fullname]}
# log.warning('Trying to add user (%r %s) who is not verified to group %s',
# user.fullname, user_name, group.name)
# # NB Other values in the form are lost, but that is probably ok
# return self.users(group.name, errors=errors,
# error_summary=error_summary(errors))
# Temporary fix for strange caching during dev
l = data_dict['users']
for d in l:
# Form javascript creates d['capacity'] == 'undefined' for
# newly added users.
# If javascript in users form is not working (such as in tests)
# it will not create a capacity value.
if 'capacity' not in d or d['capacity'] == 'undefined':
# default to 'editor'
d['capacity'] = 'editor'
context = {
"group": group,
"schema": default_group_schema(),
"model": model,
"session": model.Session
}
# Temporary cleanup of a capacity being sent without a name
users = [d for d in data_dict['users'] if len(d) == 2]
data_dict['users'] = users
model.repo.new_revision()
group_member_save(context, data_dict, 'users')
model.Session.commit()
h.redirect_to('/organisation/%s' % str(group.name))
def form_to_db_schema_api_create(self) -> dict[str, Any]:
return schema.default_group_schema()
