def __call__(self, context, field, options):
value = getattr(context, field, False)
if value is True:
return _(u'Yes')
else:
return _(u'No')
def handle_import(self):
if not self.parameters:
return
try:
portal_type = self.parameters['portal_type']
import_file = self.parameters['import_file']
format = self.get_format_from_filename(import_file.filename)
if not format in supported_formats:
raise ContentImportError(_(
u'${format} is not supported, supported are ${formats}',
mapping={
'format': format,
'formats': ', '.join(supported_formats)
}
))
count = import_people(
self.request,
self.context,
portal_type,
format,
import_file.data
)
self.status = _(
u'Successfully imported ${count} records', mapping=dict(
count=count
)
)
except ContentImportError, e:
transaction.abort()
self.raise_action_error(e.translate(self.request))
def get_field(request, person, field):
if not hasattr(person, field):
raise ContentExportError(_(u"Field '${name}' does not exist", mapping={
'name': field
}))
value = get_value(request, person, field)
if value is None:
return u''
if isinstance(value, bool):
return _(u'Yes') if value is True else _(u'No')
if isinstance(value, basestring):
return unicode(value)
if field in person.membership_fields.keys():
organizations = (api.content.get(UID=i).title for i in value.keys())
return u', '.join(organizations)
if isinstance(value, (list, tuple, set)):
return u', '.join(value)
if isinstance(value, dict):
parts = []
for key in sorted(value):
parts.append(u'{}: {}'.format(key, value[key]))
return u', '.join(parts)
if isinstance(value, date):
return unicode(isodate.date_isoformat(value))
if isinstance(value, datetime):
return unicode(isodate.datetime_isoformat(value))
if isinstance(value, time):
return unicode(isodate.time_isoformat(value))
if isinstance(value, RichTextValue):
return unicode(value.output)
if isinstance(value, (NamedImage, NamedBlobImage)):
base = person.absolute_url()
if value.filename:
return u'{}/@@download/{}/{}'.format(base, field, value.filename)
else:
return u'{}/@@download/{}'.format(base, field)
return value
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 test_error_translation(self):
err = errors.TranslatableException(_(u'Test'))
self.assertEqual(err.translate(self.request), u'Test')
err = errors.ContentImportError(_(u'Test'))
self.assertEqual(err.translate(self.request), u'Test')
err.colname = 'test'
self.assertEqual(err.translate(self.request), u'Test (Column test)')
err.rownumber = 1
self.assertEqual(
err.translate(self.request), u'Test (Row 1, Column test)'
)
def translate_position(self, request):
particles = []
if self.rownumber:
particles.append(_(u'Row ${row}', mapping=dict(
row=self.rownumber
)))
if self.colname:
particles.append(_(u'Column ${column}', mapping=dict(
column=self.colname
)))
translate = tools.translator(request)
return u', '.join(map(translate, particles))
def available_variants(self):
exports = [
('__none__', _(u'Standard'))
]
for name, export in getAdapters((self.context, ), IExportVariant):
if export.can_handle_type(self.portal_type):
exports.append((name, export.title))
return exports
def validate_attribute_values(schema, values):
obj = namedtuple('ImportObject', values.keys())(**values)
for error in getValidationErrors(schema, obj):
column = schema[error[0]].title
if isinstance(error[1], (SchemaNotFullyImplemented, RequiredMissing)):
raise ContentImportError(
_(u'Required column is missing'), colname=column
)
else:
raise ContentImportError(error, colname=column)
def handle_export(self):
try:
export_fields = self.parameters.get('export_fields')
export_fields = [
(id, title) for id, title
in self.portal_type_fields
if id in export_fields
]
review_state = self.parameters.get('review_state')
review_state = None if review_state == '__all__' else review_state
include_inactive = self.parameters.get('include_inactive')
dataset = export_people(
self.request,
self.context,
self.portal_type.id,
export_fields,
review_state,
include_inactive
)
variant = self.get_variant_by_name(self.parameters.get('variant'))
if variant:
dataset = variant.adjust_dataset(dataset, self.parameters)
if dataset is None:
raise ContentExportError(
_(u"The selected variant could not be applied")
)
format = self.parameters.get('export_format').lower()
filename = '%s.%s' % (self.context.title, format)
filename = codecs.utf_8_encode('filename="%s"' % filename)[0]
output = getattr(dataset, format)
RESPONSE = self.request.RESPONSE
RESPONSE.setHeader("Content-disposition", filename)
RESPONSE.setHeader(
"Content-Type", "application/%s;charset=utf-8" % format
)
RESPONSE.setHeader("Content-Length", len(output))
self.output = output
except ContentExportError as e:
self.raise_action_error(e.translate(self.request))
def export_people(request, container, portal_type, fields,
review_state=None, include_inactive=True):
people = get_people(container, portal_type, review_state, include_inactive)
if not people:
raise ContentExportError(_(u"No people to export"))
records = (get_record(request, person, fields) for person in people)
translate = tools.translator(request, 'seantis.people')
dataset = tablib.Dataset(headers=[translate(f[1]) for f in fields])
map(dataset.append, records)
return dataset
def filter(self):
if self.letter:
return LetterFilter(self.letter, _(u"Letter"))
for key in self.request.keys():
if key.startswith(self.filter_prefix):
val = self.request[key].decode("utf-8")
key = key.replace(self.filter_prefix, "")
field = self.has_people and self.schema.get(key, None) or None
title = field and field.title or u""
return ListFilter(key, val, title)
return None
def available_review_states(self):
all_states = [
('__all__', _(u'All'))
]
used_type = self.context.used_type()
if not used_type:
return all_states
actual_states = set(b.review_state for b in self.context.people())
wftool = api.portal.get_tool('portal_workflow')
_plone = MessageFactory('plone')
for state in actual_states:
all_states.append((
state, _plone(
wftool.getTitleForStateOnType(state, used_type.id)
)
))
return all_states
def get_attribute_values(request, record, attribute_map):
values = {}
vocabularies = get_vocabularies(request, attribute_map)
for header, field in attribute_map.items():
downloaded = download_field_from_url(field, record[header])
if downloaded is not False:
values[field.__name__] = downloaded
continue
if IDate.providedBy(field):
if not record[header]:
values[field.__name__] = None
else:
values[field.__name__] = parse_date(record[header])
continue
if IDatetime.providedBy(field):
if not record[header]:
values[field.__name__] = None
else:
values[field.__name__] = parse_datetime(record[header])
continue
if IURI.providedBy(field):
if not record[header].strip():
values[field.__name__] = None
continue
if IList.providedBy(field):
if ITextLine.providedBy(field.value_type):
values[field.__name__] = convert_to_list(record[header])
continue
if ISet.providedBy(field):
if IChoice.providedBy(field.value_type):
values[field.__name__] = set(convert_to_list(record[header]))
continue
if IChoice.providedBy(field):
if not record[header].strip():
values[field.__name__] = None
else:
vocabulary = vocabularies[header]
if record[header].lower() not in vocabulary:
raise ContentImportError(
_(
u'The ${name} column contains the '
u'unknown value ${value}',
mapping=dict(name=header, value=record[header])
)
)
values[field.__name__] = vocabulary[record[header].lower()]
continue
assert IFromUnicode.providedBy(field), """
{} does not support fromUnicode
""".format(field)
try:
values[field.__name__] = field.fromUnicode(record[header])
if isinstance(values[field.__name__], basestring):
values[field.__name__] = values[field.__name__].strip()
if isinstance(field, Text):
values[field.__name__] = values[field.__name__].replace(
'<br />', '\n'
)
except ValidationError, e:
raise ContentImportError(e.doc(), colname=header)
except ValueError, e:
raise ContentImportError(e.message, colname=header)
def available_actions(self):
yield dict(name='import', title=_(u'Import'), css_class='context')
yield dict(name='cancel', title=_(u'Cancel'))
def label(self):
return _(u"Import ${name}", mapping={
'name': self.context.title
})
def membership_fields(self):
return {
'memberships': _(u'Memberships')
}
def available_actions(self):
yield dict(name='export', title=_(u"Export"),
css_class='context allowMultiSubmit')
yield dict(name='cancel', title=_(u"Cancel"))
