def test_get_schema_from_portal_type(self):
new_type = self.new_temporary_type()
self.assertEqual(
tools.get_schema_from_portal_type(new_type.id),
new_type.lookupSchema()
)
def import_people(request, container, portal_type, format, data):
dataset = get_dataset(format, data)
attribute_map = get_attribute_map(request, dataset.headers, portal_type)
schema = tools.get_schema_from_portal_type(portal_type)
for ix, record in enumerate(dataset.dict):
log.info('processing row number {}'.format(ix+1))
try:
values = get_attribute_values(request, record, attribute_map)
# add None for missing values
for field in getFields(schema).keys():
if field not in values:
values[field] = None
validate_attribute_values(schema, values)
api.content.create(
container=container,
type=portal_type,
id='',
**values
)
except ContentImportError, e:
raise ContentImportError(
e.message, rownumber=ix+1, colname=e.colname
)
except Exception, e:
log.exception('error importing people')
raise ContentImportError(e.message, rownumber=ix+1)
def get_name_from_person(obj):
schema = tools.get_schema_from_portal_type(obj.portal_type)
fields = get_title_fields(schema)
title = u' '.join((getattr(obj, field, u'') or u'' for field in fields))
return title.strip()
def __call__(self, context, field, options):
value = getattr(context, field)
schema = tools.get_schema_from_portal_type(context.portal_type)
name = schema.get(field).vocabularyName
voc = zope.component.getUtility(IVocabularyFactory, name)(context)
try:
return voc.getTerm(value).title
except LookupError:
return value
def get_sortable_title_text(obj):
schema = tools.get_schema_from_portal_type(obj.portal_type)
order = list(get_order(schema))
if order:
title = u' '.join((getattr(obj, field, u'') for field in order))
title = title.strip()
if not order or not title:
title = getattr(obj, 'title', u'')
return title.strip()
def get_attribute_map(request, headers, portal_type):
if not headers:
raise ContentImportError(_(u'No column headers were found'))
schema = tools.get_schema_from_portal_type(portal_type)
attribute_map = {}
fields = getFields(schema)
known_titles = dict((field.title, field) for field in fields.values())
known_fields = dict((key, field) for key, field in fields.items())
translate = tools.translator(request)
known_translated_titles = dict(
(translate(field.title), field) for field in fields.values()
)
for header in headers:
if header in known_translated_titles:
field = known_translated_titles[header]
elif header in known_fields:
field = known_fields[header]
elif header in known_titles:
field = known_titles[header]
else:
log.warn(u"The header '{}' was ignored.".format(header))
continue
if field in attribute_map.values():
raise ContentImportError(
_(
u'The ${name} column is specified more than once',
mapping=dict(name=header)
)
)
if field in ('title', 'id'):
raise ContentImportError(
_(
u'The ${name} column is invalid. "title" and "id" are '
u'reserved fieldnames which may not be used.',
mapping=dict(name=header)
)
)
attribute_map[header] = field
return attribute_map
def get_value(request, person, field):
value = getattr(person, field)
schema = tools.get_schema_from_portal_type(person.portal_type)
try:
name = schema.get(field).vocabularyName
except AttributeError:
return getattr(person, field)
vocabulary = zope.component.getUtility(IVocabularyFactory, name)(person)
try:
translate = tools.translator(request, 'seantis.people')
return translate(vocabulary.getTerm(value).title)
except LookupError:
return value
def schema(self):
return tools.get_schema_from_portal_type(self.context.portal_type)
