def get_attributes(self):
return [
{
'id':
'reference_number',
'title':
dossier_mf(u'label_reference_number',
default=u'Reference Number')
},
{
'id': 'title',
'title': dossier_mf('label_title', default=u'title')
},
{
'id': 'start',
'title': dossier_mf(u'label_start', default=u'Opening Date'),
'number_format': DATE_NUMBER_FORMAT
},
{
'id': 'end',
'title': dossier_mf(u'label_end', default=u'Closing Date'),
'number_format': DATE_NUMBER_FORMAT
},
{
'id':
'public_trial',
'title':
base_mf(u'label_public_trial', default=u'Public Trial'),
'transform':
StringTranslater(self.request, 'opengever.base').translate
},
{
'id':
'archival_value',
'title':
base_mf(u'label_archival_value', default=u'Archival value'),
'transform':
StringTranslater(self.request, 'opengever.base').translate
},
{
'id':
'archival_value_annotation',
'title':
base_mf(u'label_archival_value_annotation',
default=u'archivalValueAnnotation'),
'transform':
StringTranslater(self.request, 'opengever.base').translate
},
{
'id': 'appraisal',
'title': _(u'label_appraisal', default=u'Appraisal'),
'transform': readable_appraisal
},
]
def get_dossier_attributes(self):
return [
{
'id': 'Title',
'title': _('label_title', default=u'Title'),
'transform': value
},
{
'id': 'start',
'title': _(u'label_start', default=u'Opening Date'),
'number_format': DATE_NUMBER_FORMAT
},
{
'id': 'end',
'title': _(u'label_end', default=u'Closing Date'),
'number_format': DATE_NUMBER_FORMAT
},
{
'id': 'responsible',
'title': _(u'label_responsible', default='Responsible'),
'transform': readable_author
},
{
'id': 'review_state',
'title': _('label_review_state', default='Review state'),
'transform': StringTranslater(self.request, 'plone').translate
},
{
'id': 'reference',
'title': _(u'label_reference_number',
default=u'Reference Number')
},
]
def _columns(self):
return [
{'id': 'reference',
'title': _(u'label_document_reference_number')},
{'id': 'sequence_number',
'title': _(u'label_document_sequence_number')},
{'id': 'Title',
'sort_index': 'sortable_title',
'title': _(u'label_title', default=u'Title')},
{'id': 'document_author',
'title': _(u'label_author', default=u'Author'),
'sort_index': 'sortable_author',
'transform': readable_author},
{'id': 'document_date',
'title': _(u'label_document_date', default=u'Document Date'),
'transform': readable_date},
{'id': 'receipt_date',
'title': _(u'label_document_receipt_date'),
'transform': readable_date},
{'id': 'delivery_date',
'title': _(u'label_document_delivery_date'),
'transform': readable_date},
{'id': 'checked_out',
'title': _(u'label_document_checked_out_by'),
'transform': readable_author},
{'id': 'public_trial',
'title': _(u'label_public_trial'),
'transform': StringTranslater(
self.request, 'opengever.base').translate},
{'id': 'containing_dossier',
'title': _(u'label_dossier_title')},
]
def test_excel_reporter_value_rows(self):
translation_request = Environment(('de', 'ch'))
base_translater = StringTranslater(translation_request,
'opengever.base').translate
columns = (
{
'id': 'title',
'title': _('label_title', default='Title')
},
{
'id': 'classification',
'title': u'fooclass',
'transform': base_translater
},
{
'id': 'Title',
'title': u'footitle',
'callable': True
},
{
'id': 'unicorn',
'title': _('label_unicorn', default='Pony'),
'default': u'Rainbows!'
},
)
self.login(self.regular_user)
reporter = XLSReporter(self.request, columns, (self.document, ))
workbook = self.get_workbook(reporter())
expected_row = [
u'Vertr\xe4gsentwurf', u'Nicht klassifiziert',
u'Vertr\xe4gsentwurf', u'Rainbows!'
]
self.assertEquals(
expected_row,
[cell.value for cell in list(workbook.active.rows)[-1]])
def get_dossier_attributes(self):
return [
{
'id': 'Title',
'title': _('label_title', default=u'title'),
'transform': to_unicode
},
{
'id': 'start',
'title': _(u'label_start', default=u'Opening Date'),
'transform': format_datetime,
'style': get_date_style()
},
{
'id': 'end',
'title': _(u'label_end', default=u'Closing Date'),
'transform': format_datetime,
'style': get_date_style()
},
{
'id': 'responsible',
'title': _(u'label_responsible', default='Responsible'),
'transform': readable_author
},
{
'id': 'review_state',
'title': _('label_review_state', default='Review state'),
'transform': StringTranslater(self.request, 'plone').translate
},
{
'id': 'reference',
'title': _(u'label_reference_number',
default=u'Reference Number')
},
]
def setUp(self):
super(TestReporter, self).setUp()
create(Builder('ogds_user').id('test_user_0'))
create(Builder('ogds_user').id('test_user_1'))
self.request = self.mocker.mock()
self.brains = []
for i in range(2):
brain = self.stub()
self.expect(brain.Title).result('Objekt %i' % (i))
self.expect(brain.missing).result(MissingValue)
self.expect(
brain.start).result(datetime(2012, 2, 25) + timedelta(i))
self.expect(brain.responsible).result('test_user_%i' % (i))
self.expect(brain.review_state).result('dossier-state-active')
self.brains.append(brain)
self.replay()
translation_request = Environment(('de', 'de'))
self.test_attributes = [
{
'id': 'Title',
'title': _('label_title', default='Title')
},
{
'id': 'missing',
'missing': 'Missing',
},
{
'id': 'start',
'title': _('label_start', default='Start'),
'number_format': DATE_NUMBER_FORMAT
},
{
'id': 'responsible',
'title': _('label_responsible', default='Responsible'),
'transform': readable_author
},
{
'id':
'review_state',
'title':
_('label_review_state', default='Review state'),
'transform':
StringTranslater(translation_request, 'plone').translate
},
]
def __call__(self):
data = generate_report(self.request, self.context)
if not data:
msg = StringTranslater(self.request,
'opengever.repository').translate(
_(u'Could not generate the report.'))
IStatusMessage(self.request).addStatusMessage(msg, type='error')
return self.request.RESPONSE.redirect(self.context.absolute_url())
response = self.request.RESPONSE
response.setHeader(
'Content-Type',
'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet'
)
set_attachment_content_disposition(self.request,
"repository_report.xlsx")
return data
def _columns(self):
return [
{'id': 'title', 'title': _('label_title')},
{'id': 'review_state', 'title': _('review_state'),
'transform': StringTranslater(
self.context.REQUEST, 'plone').translate},
{'id': 'deadline', 'title': _('label_deadline'),
'number_format': DATE_NUMBER_FORMAT},
{'id': 'completed', 'title': _('label_completed'),
'number_format': DATE_NUMBER_FORMAT},
{'id': 'containing_dossier', 'title': _('label_dossier')},
{'id': 'issuer', 'title': _('label_issuer'),
'transform': readable_author},
{'id': 'issuing_org_unit_label',
'title': _('label_issuing_org_unit')},
{'id': 'responsible', 'title': _('label_responsible'),
'transform': readable_author},
{'id': 'task_type', 'title': _('label_task_type'),
'transform': task_type_helper},
{'id': 'admin_unit_id', 'title': _('label_admin_unit_id')},
{'id': 'sequence_number', 'title': _('label_sequence_number')},
]
def render(self):
tasks = get_selected_items(self.context, self.request)
tasks = [tt for tt in tasks]
if not tasks:
msg = _(u'error_no_items',
default=u'You have not selected any items.')
IStatusMessage(self.request).addStatusMessage(msg, type='error')
if self.request.get('orig_template'):
return self.request.RESPONSE.redirect(
self.request.form['orig_template'])
else:
return self.request.RESPONSE.redirect(
self.context.absolute_url())
task_attributes = [
{
'id': 'title',
'title': _('label_task_title')
},
{
'id':
'review_state',
'title':
_('review_state'),
'transform':
StringTranslater(self.context.REQUEST, 'plone').translate
},
{
'id': 'deadline',
'title': _('label_deadline'),
'number_format': DATE_NUMBER_FORMAT
},
{
'id': 'completed',
'title': _('label_completed'),
'number_format': DATE_NUMBER_FORMAT
},
{
'id': 'containing_dossier',
'title': _('label_dossier_title')
},
{
'id': 'issuer',
'title': _('label_issuer'),
'transform': readable_author
},
{
'id': 'issuing_org_unit_label',
'title': _('label_issuing_org_unit')
},
{
'id': 'responsible',
'title': _('label_responsible'),
'transform': readable_author
},
{
'id': 'task_type',
'title': _('label_task_type'),
'transform': task_type_helper
},
{
'id': 'admin_unit_id',
'title': _('label_admin_unit_id')
},
{
'id': 'sequence_number',
'title': _('label_sequence_number')
},
]
reporter = XLSReporter(self.context.REQUEST,
task_attributes,
tasks,
sheet_title=translate(_('label_tasks',
default=u'Tasks'),
context=self.request),
footer='%s %s' %
(datetime.now().strftime('%d.%m.%Y %H:%M'),
get_current_admin_unit().id()))
data = reporter()
if not data:
msg = _(u'Could not generate the report.')
IStatusMessage(self.request).addStatusMessage(msg, type='error')
return self.request.RESPONSE.redirect(self.context.absolute_url())
response = self.request.RESPONSE
response.setHeader(
'Content-Type',
'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet'
)
set_attachment_content_disposition(self.request, "task_report.xlsx")
return data
def generate_report(request, context):
# Translations from opengever.base
base_translater = StringTranslater(request, 'opengever.base').translate
label_classification = base_translater(u'label_classification')
label_privacy_layer = base_translater(u'label_privacy_layer')
label_public_trial = base_translater(u'label_public_trial')
label_retention_period = base_translater(u'label_retention_period')
label_retention_period_annotation = base_translater(
u'label_retention_period_annotation')
label_archival_value = base_translater(u'label_archival_value')
label_archival_value_annotation = base_translater(
u'label_archival_value_annotation')
label_custody_period = base_translater(u'label_custody_period')
# Translations local to opengever.repository
repository_translater = StringTranslater(request,
'opengever.repository').translate
label_valid_from = repository_translater(u'label_valid_from')
label_valid_until = repository_translater(u'label_valid_until')
# Translations defined here for opengever.repository
label_repository_number = repository_translater(
_(
u'label_repository_number',
default=u'Repository number',
))
label_repositoryfolder_title_de = repository_translater(
_(
u'label_repositoryfolder_title_de',
default=u'Repositoryfolder title (German)',
))
label_repositoryfolder_title_fr = repository_translater(
_(
u'label_repositoryfolder_title_fr',
default=u'Repositoryfolder title (French)',
))
label_repositoryfolder_description = repository_translater(
_(
u'label_repositoryfolder_description',
default=u'Repositoryfolder description',
))
label_blocked_inheritance = repository_translater(
_(
u'label_blocked_inheritance',
default=u'Blocked inheritance',
))
label_groupnames_with_reader_role = repository_translater(
_(
u'label_groupnames_with_reader_role',
default=u'Read dossiers',
))
label_groupnames_with_contributor_role = repository_translater(
_(
u'label_groupnames_with_contributor_role',
default=u'Create dossiers',
))
label_groupnames_with_editor_role = repository_translater(
_(
u'label_groupnames_with_editor_role',
default=u'Edit dossiers',
))
label_groupnames_with_reviewer_role = repository_translater(
_(
u'label_groupnames_with_reviewer_role',
default=u'Close dossiers',
))
label_groupnames_with_publisher_role = repository_translater(
_(
u'label_groupnames_with_publisher_role',
default=u'Reactivate dossiers',
))
label_groupnames_with_manager_role = repository_translater(
_(
u'label_groupnames_with_manager_role',
default=u'Manage dossiers',
))
column_map = (
{
'id': 'get_repository_number',
'title': label_repository_number,
'fold_by_method': repository_number_to_outine_level,
'callable': True
}, # noqa
{
'id': 'title_de',
'title': label_repositoryfolder_title_de
},
{
'id': 'title_fr',
'title': label_repositoryfolder_title_fr
},
{
'id': 'description',
'title': label_repositoryfolder_description
},
{
'id': 'classification',
'title': label_classification,
'transform': base_translater,
'default': u''
},
{
'id': 'privacy_layer',
'title': label_privacy_layer,
'transform': base_translater,
'default': u''
},
{
'id': 'public_trial',
'title': label_public_trial,
'transform': base_translater,
'default': u''
},
{
'id': 'get_retention_period',
'title': label_retention_period,
'callable': True,
'default': u''
},
{
'id': 'get_retention_period_annotation',
'title': label_retention_period_annotation,
'callable': True,
'default': u''
}, # noqa
{
'id': 'get_archival_value',
'title': label_archival_value,
'transform': base_translater,
'callable': True,
'default': u''
}, # noqa
{
'id': 'get_archival_value_annotation',
'title': label_archival_value_annotation,
'callable': True,
'default': u''
},
{
'id': 'get_custody_period',
'title': label_custody_period,
'callable': True,
'default': u''
},
{
'id': 'valid_from',
'title': label_valid_from
},
{
'id': 'valid_until',
'title': label_valid_until
},
{
'id': '__ac_local_roles_block__',
'title': label_blocked_inheritance,
'transform': bool_label,
'default': False
},
{
'id': 'get_groupnames_with_reader_role',
'title': label_groupnames_with_reader_role,
'callable': True
},
{
'id': 'get_groupnames_with_contributor_role',
'title': label_groupnames_with_contributor_role,
'callable': True
},
{
'id': 'get_groupnames_with_editor_role',
'title': label_groupnames_with_editor_role,
'callable': True
},
{
'id': 'get_groupnames_with_reviewer_role',
'title': label_groupnames_with_reviewer_role,
'callable': True
},
{
'id': 'get_groupnames_with_publisher_role',
'title': label_groupnames_with_publisher_role,
'callable': True
},
{
'id': 'get_groupnames_with_manager_role',
'title': label_groupnames_with_manager_role,
'callable': True
},
)
# We sort these by reference number to preserve user experienced ordering
active_formatter = api.portal.get_registry_record(
name='formatter', interface=IReferenceNumberSettings)
formatter = queryAdapter(api.portal.get(),
IReferenceNumberFormatter,
name=active_formatter)
repository_brains = sorted(
api.content.find(context,
object_provides=IRepositoryFolder.__identifier__),
key=formatter.sorter,
)
repository_folders = [context] + [
brain.getObject() for brain in repository_brains
]
# XXX - the excel importer expects 4 non-meaningful rows
return XLSReporter(
request,
column_map,
repository_folders,
sheet_title=repository_translater(u'RepositoryRoot'),
blank_header_rows=4,
)()
def bool_label(value):
translater = StringTranslater(api.portal.get().REQUEST,
'opengever.repository').translate
return (translater(_(u'label_true', default='Yes'))
if value else translater(_(u'label_false', default='No')))
def test_xlsreporter(self):
contact_info = self.stub()
self.mock_utility(contact_info, IContactInformation, name=u"")
self.expect(contact_info.is_user(ANY)).result(True)
self.expect(
contact_info.describe(ANY)).result('Describe text for a user')
request = self.mocker.mock()
brains = []
for i in range(2):
brain = self.stub()
self.expect(brain.Title).result('Objekt %i' % (i))
self.expect(brain.missing).result(MissingValue)
self.expect(
brain.start).result(datetime(2012, 2, 25) + timedelta(i))
self.expect(brain.responsible).result('Test user %i' % (i))
self.expect(brain.review_state).result('dossier-state-active')
brains.append(brain)
self.replay()
translation_request = Environment(('de', 'de'))
test_attributes = [
{
'id': 'Title',
'title': _('label_title', default='Title')
},
#test missingvalue
{
'id': 'missing',
'missing': 'Missing',
},
{
'id': 'start',
'title': _('label_start', default='Start'),
'transform': format_datetime,
'style': get_date_style()
},
{
'id': 'responsible',
'title': _('label_responsible', default='Responsible'),
'transform': readable_author
},
{
'id':
'review_state',
'title':
_('label_review_state', default='Review state'),
'transform':
StringTranslater(translation_request, 'plone').translate
},
]
# generate the report.xls
reporter = XLSReporter(request, test_attributes, brains)
data = reporter()
# check the generate xls with the xlrd module
wb = xlrd.open_workbook(file_contents=data)
sheet = wb.sheets()[0]
labels = sheet.row(0)
self.assertEquals(
[cell.value for cell in labels],
[u'Title', u'', u'Start', u'Responsible', u'Review state'])
row1 = sheet.row(1)
self.assertEquals([cell.value for cell in row1], [
u'Objekt 0', u'', u'25.02.2012', u'Describe text for a user',
u'dossier-state-active'
])
row2 = sheet.row(2)
self.assertEquals([cell.value for cell in row2], [
u'Objekt 1', u'', u'26.02.2012', u'Describe text for a user',
u'dossier-state-active'
])
