def render(self):
if not self.request.get('paths'):
msg = _(u'error_no_items',
default=u'You have not selected any items.')
IStatusMessage(self.request).addStatusMessage(msg, type='error')
return_temp = self.request.get('orig_template',
self.context.absolute_url())
return self.request.RESPONSE.redirect(return_temp)
dossiers = self.get_selected_dossiers()
# generate the xls data with the XLSReporter
reporter = XLSReporter(self.request, self.get_dossier_attributes(),
dossiers)
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, "dossier_report.xlsx")
return data
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 __call__(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())
reporter = XLSReporter(
self.context.REQUEST,
self.columns(),
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())
)
return self.return_excel(reporter)
def test_label_row_is_translated_attribute_titles(self):
columns = ({
'id': 'title',
'title': _('label_title', default='Title')
}, )
self.login(self.regular_user)
reporter = XLSReporter(self.request, columns, (self.document, ))
workbook = self.get_workbook(reporter())
self.assertEquals(
[u'Title'], [cell.value for cell in list(workbook.active.rows)[0]])
def test_value_rows(self):
reporter = XLSReporter(self.request, self.test_attributes, self.brains)
workbook = self.get_workbook(reporter())
rows = list(workbook.active.rows)
self.assertEquals([
u'Objekt 0', None,
datetime(2012, 2, 25), u'test_user_0 (test_user_0)',
u'dossier-state-active'
], [cell.value for cell in rows[1]])
self.assertEquals([
u'Objekt 1', None,
datetime(2012, 2, 26), u'test_user_1 (test_user_1)',
'dossier-state-active'
], [cell.value for cell in rows[2]])
def __call__(self):
if not self.request.get('paths'):
msg = _(
u'error_no_items', default=u'You have not selected any Items')
IStatusMessage(self.request).addStatusMessage(msg, type='error')
return_temp = self.request.get(
'orig_template', self.context.absolute_url())
return self.request.RESPONSE.redirect(return_temp)
# XXX: Also make pseudo-relative paths work
# (as sent by the new gever-ui)
rewrite_path_list_to_absolute_paths(self.request)
documents = self.get_selected_documents()
reporter = XLSReporter(self.request, self.columns(), documents)
return self.return_excel(reporter)
def __call__(self):
reporter = XLSReporter(self.request,
self.get_attributes(),
self.context.get_dossier_representations(),
sheet_title=self.get_sheet_title())
response = self.request.RESPONSE
data = reporter()
if not data:
msg = _(u'The report could not been generated.')
api.portal.show_message(message=msg,
request=self.request,
type='error')
return response.redirect(self.context.absolute_url())
response.setHeader(
'Content-Type',
'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet'
)
set_attachment_content_disposition(self.request, self.get_file_name())
return data
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 test_set_sheet_title_for_active_workbook_sheet(self):
title = 'Aufgaben\xc3\xbcbersicht'.decode('utf-8')
reporter = XLSReporter(None, (), (), sheet_title=title)
workbook = self.get_workbook(reporter())
self.assertEquals(title, workbook.active.title)
def test_label_row_is_translated_attribute_titles(self):
reporter = XLSReporter(self.request, self.test_attributes, self.brains)
workbook = self.get_workbook(reporter())
self.assertEquals(
[u'Title', None, u'Start', u'Responsible', u'Review state'],
[cell.value for cell in list(workbook.active.rows)[0]])
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'
])
