def generateDocumentText(self):
"""Generate document using template from templates stored in
src/bungeni_custom/reporting/templates/documents
Each template has a config parameter with the document type for
which it may be used.
"""
template_vocabulary = queryUtility(IVocabularyFactory,
"bungeni.vocabulary.DocumentXHTMLTemplates"
)
doc_templates = [ term.value for term in template_vocabulary() if
self.document.type in term.doctypes
]
log.debug("Looking for templates to generate [%s] report. Found : %s",
self.document.type, doc_templates
)
if len(doc_templates) == 0:
self.error_messages.append(
_(u"No template for document of type: ${dtype}. Contact admin.",
mapping={ "dtype": self.document.type }
)
)
raise DocumentGenerationError(
"No template found to generate this document"
)
#!+REPORTS(mrb, OCT-2011) Provide UI to select templates if more than 1
generator = generators.ReportGeneratorXHTML(doc_templates[0],
self.document
)
#return generator.generateReport()
return generator.generateReport()
def generateDocumentText(self):
"""Generate document using template from templates stored in
src/bungeni_custom/reporting/templates/documents
Each template has a config parameter with the document type for
which it may be used.
"""
def default_template(templates):
default_templates = filter(lambda term: "default" in term.doctypes,
templates)
if default_templates:
return default_templates[0].value
return None
template_vocabulary = vocabulary.document_xhtml_template_factory()
doc_templates = [
term.value for term in template_vocabulary
if self.document.type in term.doctypes
]
log.debug("Looking for templates to generate [%s] report. Found : %s",
self.document.type, doc_templates)
if doc_templates:
doc_template = doc_templates[0]
else:
doc_template = default_template(template_vocabulary)
if doc_template is None:
self.error_messages.append(
_(u"No template for document of type: ${dtype}. Contact admin.",
mapping={"dtype": self.document.type}))
raise DocumentGenerationError(
"No template found to generate this document")
generator = generators.ReportGeneratorXHTML(doc_template,
self.document)
return generator.generateReport()
def generate_preview(self):
sitting = removeSecurityProxy(self.context)
sittings = [data.ExpandedSitting(sitting)]
generator = generators.ReportGeneratorXHTML(self.get_template())
#!+TAGS(mb, Feb-2013) Deprecate with tags. Configure as wf/feature.
if "minutes" in sitting.status:
title = generator.title = _(u"Sitting Votes and Proceedings")
else:
title = generator.title = _(u"Sitting Agenda")
generator.context = data.ReportContext(sittings=sittings, title=title)
return generator.generateReport()
def generateContent(self, data):
self.start_date = (data.get("start_date") or
datetime.datetime.today().date()
)
generator = generators.ReportGeneratorXHTML(data.get("report_type"))
self.title = generator.title
self.publication_number = data.get("publication_number")
self.end_date = self.get_end_date(self.start_date, generator.coverage)
self.buildSittings(self.start_date, self.end_date)
generator.context = self
return generator.generateReport()
def generatePreview(self):
vocabulary = component.queryUtility(
IVocabularyFactory, "bungeni.vocabulary.ReportXHTMLTemplates")
preview_template = filter(lambda t: t.title == "Weekly Business",
vocabulary.terms)[0]
doc_template = preview_template.value
generator = generators.ReportGeneratorXHTML(doc_template)
self.title = preview_template.title
self.language = generator.language
self.sittings = [ExpandedSitting(removeSecurityProxy(self.context))]
generator.context = self
return generator.generateReport()
def default_reports(sitting, event):
wf = IWorkflow(sitting)
if sitting.status in wf.get_state_ids(tagged=["published"]):
sitting = removeSecurityProxy(sitting)
sittings = [ExpandedSitting(sitting)]
report_context = ReportContext(sittings=sittings)
report = domain.Report()
session = Session()
# !+GROUP_AS_OWNER(mr, apr-2012) we assume for now that the "owner" of
# the report is the currently logged in user.
report.owner_id = get_db_user_id()
report.created_date = datetime.datetime.now()
report.group_id = sitting.group_id
# generate using html template in bungeni_custom
vocabulary = component.queryUtility(
schema.interfaces.IVocabularyFactory,
"bungeni.vocabulary.ReportXHTMLTemplates"
)
preview_template = filter(
lambda t: t.title=="Sitting Agenda", vocabulary.terms
)[0]
doc_template = preview_template.value
generator = generators.ReportGeneratorXHTML(doc_template)
generator.context = report_context
report.language = generator.language
if sitting.status in wf.get_state_ids(tagged=["publishedminutes"]):
report.short_title = generator.title = _(u"Sitting Votes and "
u" Proceedings"
)
else:
report.short_title = generator.title = _(u"Sitting Agenda")
report.body = generator.generateReport()
session.add(report)
session.flush()
notify(ObjectCreatedEvent(report))
sr = domain.SittingReport()
sr.report = report
sr.sitting = sitting
session.add(sr)
session.flush()
notify(ObjectCreatedEvent(sr))
def default_reports(sitting, event):
#!+REPORTS(mb, Feb-2013) add a publish_report action - remove this handler
if "published" in sitting.status:
sitting = removeSecurityProxy(sitting)
report_type = "sitting_agenda"
report_title = _("report_title_sitting_agenda",
default=u"Sitting Agenda")
if "minutes" in sitting.status:
report_type = "sitting_minutes"
report_title = _("report_title_votes_and_proceedings",
default=u"Sitting Votes and Proceedings")
sittings = [ExpandedSitting(sitting)]
report = domain.Report()
session = Session()
# !+GROUP_AS_OWNER(mr, apr-2012) we assume for now that the "owner" of
# the report is the currently logged in user.
report.owner_id = get_login_user().user_id
report.created_date = datetime.datetime.now()
report.group_id = sitting.group_id
# generate using html template in bungeni_custom
vocab = vocabulary.report_xhtml_template_factory
term = vocab.getTermByFileName(report_type)
doc_template = term and term.value or vocab.terms[0].value
generator = generators.ReportGeneratorXHTML(doc_template)
generator.title = report_title
report_title_i18n = translate(report_title,
target_language=generator.language)
report_context = ReportContext(sittings=sittings,
title=report_title_i18n)
generator.context = report_context
report.title = report_title_i18n
report.language = generator.language
report.body = generator.generateReport()
session.add(report)
session.flush()
notify(ObjectCreatedEvent(report))
sr = domain.SittingReport()
sr.report = report
sr.sitting = sitting
session.add(sr)
session.flush()
notify(ObjectCreatedEvent(sr))
def default_reports(sitting, event):
#!+REPORTS(mb, Feb-2013) - remove this handler for workflow events:
# EITHER a publish_report action, maybe configure this as a workflow action
# (so not hardwired to status/workflow event)
# OR make it part of sitting feature options e.g. publish state and report
# template.
if "published" in sitting.status:
sitting = removeSecurityProxy(sitting)
report_type = "sitting_agenda"
report_title = _("report_title_order_of_the_day",
default=u"Order of the day")
if "minutes" in sitting.status:
report_type = "sitting_minutes"
report_title = _("report_title_votes_and_proceedings",
default=u"Votes and Proceedings")
sittings = [ExpandedSitting(sitting)]
report = domain.Report()
session = Session()
# !+GROUP_AS_OWNER(mr, apr-2012) we assume for now that the "owner" of
# the report is the currently logged in user.
report.owner_id = get_login_user().user_id
report.created_date = datetime.datetime.now()
report.group_id = sitting.group_id
# !+ReportXHTMLTemplateFactory
# generate using html template in bungeni_custom
vocab = vocabulary.report_xhtml_template_factory(sitting)
try:
report_template_path = vocab.getTermByToken(report_type).value
except LookupError:
vtokens = [t.token for t in vocab._terms]
# first check if we have any values in the reports vocab for this context
if not vtokens:
log.error(
"Sitting %s Workflow Transition Handler - "
"entry for report type %r NOT found in EMPTY vocabulary: %s",
sitting, report_type, vtokens)
raise
# ok, as a tmp workaround, pick off the first term value in the reports vocab
log.warning(
"Sitting %s Workflow Transition Handler - "
"entry for report type %r NOT found in vocabulary: %s - "
"proceeding with the template for first entry found: %r ",
sitting, report_type, vtokens, vtokens[0])
report_template_path = vocab._terms[0].value
generator = generators.ReportGeneratorXHTML(report_template_path)
generator.title = report_title
report_title_i18n = translate(report_title,
target_language=generator.language)
report_context = ReportContext(sittings=sittings,
title=report_title_i18n)
generator.context = report_context
report.title = report_title_i18n
report.language = generator.language
report.body = generator.generate_report(common.get_request())
session.add(report)
session.flush()
notify(ObjectCreatedEvent(report))
sr = domain.SittingReport()
sr.report = report
sr.sitting = sitting
session.add(sr)
session.flush()
notify(ObjectCreatedEvent(sr))
