def handle_publish(self, action, data):
self.generated_content = self.generateContent(data)
if IWorkspaceScheduling.providedBy(self.request):
if not hasattr(self.context, "group_id"):
context_group_id = ISchedulingContext(self.context).group_id
else:
context_group_id = self.context.group_id
else:
#get the chamber id
context_group_id = get_chamber_for_context(
self.context).parliament_id
report = domain.Report(
title=self.title,
start_date=self.start_date,
end_date=self.end_date,
body=self.generated_content,
owner_id=get_login_user().user_id, # !+GROUP_AS_OWNER
language=self.language,
group_id=context_group_id)
session = Session()
session.add(report)
session.flush()
notify(ObjectCreatedEvent(report))
self.status = _(u"Report has been processed and saved")
return self.template()
def handle_save(self, action, data):
report = domain.Report()
session = Session()
report.body_text = data["body_text"]
report.start_date = data["start_date"]
report.end_date = data["end_date"]
report.note = data["note"]
report.report_type = data["report_type"]
report.short_name = data["report_type"]
owner_id = get_db_user_id()
'''!+TODO(Miano, 18/08/2010) The admin user is currently not a db user
thus the line above returns None when the admin publishes a report.
to go around this if it returns None, just query the db for users
and set the owner id to be the first result'''
if owner_id is not None:
report.owner_id = owner_id
else:
query = session.query(domain.User)
results = query.all()
report.owner_id = results[0].user_id
report.language = "en"
report.created_date = datetime.datetime.now()
report.group_id = self.context.group_id
session.add(report)
notify(ObjectCreatedEvent(report))
# !+INVALIDATE(mr, sep-2010)
container.invalidate_caches_for("Report", "add")
if "sittings" in data.keys():
try:
ids = data["sittings"].split(",")
for id_number in ids:
sit_id = int(id_number)
sitting = session.query(domain.GroupSitting).get(sit_id)
sr = domain.SittingReport()
sr.report = report
sr.sitting = sitting
session.add(sr)
# !+INVALIDATE(mr, sep-2010) via an event...
container.invalidate_caches_for("SittingReport", "add")
except:
#if no sittings are present in report or some other error occurs
pass
session.commit()
if IGroupSitting.providedBy(self.context):
back_link = "./schedule"
elif ISchedulingContext.providedBy(self.context):
back_link = "./"
else:
raise NotImplementedError
self.request.response.redirect(back_link)
def handle_save(self, action, data):
report = domain.Report()
session = Session()
report.body_text = data['body_text']
report.start_date = data['start_date']
report.end_date = data['end_date']
report.note = data['note']
report.report_type = data['report_type']
report.short_name = data['report_type']
owner_id = get_db_user_id()
'''!+TODO(Miano, 18/08/2010) The admin user is currently not a db user
thus the line above returns None when the admin publishes a report.
to go around this if it returns None, just query the db for users
and set the owner id to be the first result'''
if owner_id is not None:
report.owner_id = owner_id
else:
query = session.query(domain.User)
results = query.all()
report.owner_id = results[0].user_id
report.language = "en"
report.created_date = datetime.datetime.now()
report.group_id = self.context.group_id
session.add(report)
notify(ObjectCreatedEvent(report))
ids = data["sittings"].split(",")
for id in ids:
try:
sit_id = int(id)
except:
continue
sitting = session.query(domain.GroupSitting).get(sit_id)
sr = domain.SittingReport()
sr.report = report
sr.sitting = sitting
session.add(sr)
session.commit()
if IGroupSitting.providedBy(self.context):
back_link = './schedule'
elif ISchedulingContext.providedBy(self.context):
back_link = './'
else:
raise NotImplementedError
self.request.response.redirect(back_link)
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 __call__(self):
body_text = self.request.form['body_text']
session = Session()
report = domain.Report()
start_date = self.request.form['start_date']
end_date = self.request.form['end_date']
report.start_date = start_date
report.end_date = end_date
report.created_date = datetime.datetime.now()
report.note = self.request.form['note']
report.report_type = self.request.form['report_type']
report.body_text = body_text
report.user_id = get_principal_id()
report.group_id = self.context.group_id
report.language = "en"
session.add(report)
if self.request.form['single'] == "False":
self.sitting_items = self.get_sittings_items(start_date, end_date)
else:
self.sitting_items = []
st = self.context.sitting_id
sitting = session.query(domain.GroupSitting).get(st)
self.sitting_items.append(sitting)
for sitting in self.sitting_items:
sr = domain.SittingReport()
sr.report = report
sr.sitting = sitting
session.add(sr)
session.flush()
rpm = zope.securitypolicy.interfaces.IRolePermissionMap(report)
rpm.grantPermissionToRole(u'zope.View', 'bungeni.Anybody')
if IGroupSitting.providedBy(self.context):
back_link = './schedule'
elif ISchedulingContext.providedBy(self.context):
back_link = './'
else:
raise NotImplementedError
self.request.response.redirect(back_link)
def default_reports(sitting, event):
if sitting.status in ("published_agenda", "published_minutes"):
sitting = removeSecurityProxy(sitting)
sittings = []
sittings.append(sitting)
report = domain.Report()
session = Session()
#!+REPORTS(miano, dec-2010) using test request here is not quite right
# TODO : fix this.
from zope.publisher.browser import TestRequest
report.start_date = sitting.start_date
report.end_date = sitting.end_date
# The owner ID is the ID of the user that performed the last workflow
# change
for change in reversed(sitting.changes):
if change.action == "workflow":
owner_id = change.user_id
break
assert owner_id is not None, _(
"No user is defined. Are you logged in as Admin?")
report.owner_id = owner_id
report.language = get_default_language()
report.created_date = datetime.datetime.now()
report.group_id = sitting.group_id
if sitting.status == 'published_agenda':
report.short_name = _(u"Sitting Agenda")
drc = DefaultReportContent(sittings, report.short_name, False)
report.body_text = DefaultReportView(drc, TestRequest())()
elif sitting.status == 'published_minutes':
report.short_name = _(u"Sitting Votes and Proceedings")
drc = DefaultReportContent(sittings, report.short_name, True)
report.body_text = DefaultReportView(drc, TestRequest(), False)()
session.add(report)
session.flush()
notify(ObjectCreatedEvent(report))
sr = domain.SittingReport()
sr.report = report
sr.sitting = sitting
session.add(sr)
session.commit()
notify(ObjectCreatedEvent(sr))
def handle_publish(self, action, data):
self.generated_content = self.generateContent(data)
if not hasattr(self.context, "group_id"):
context_group_id = ISchedulingContext(self.context).group_id
else:
context_group_id = self.context.group_id
report = domain.Report(short_name=self.title,
start_date=self.start_date,
end_date=self.end_date,
body_text=self.generated_content,
owner_id=get_db_user_id(),
language=self.language,
group_id=context_group_id)
session = Session()
session.add(report)
session.flush()
self.status = _(u"Report has been processed and saved")
return self.template()
def handle_save(self, action, data):
report = domain.Report()
session = Session()
report.body = data["body"]
report.start_date = data["start_date"]
report.end_date = data["end_date"]
report.note = data["note"]
report.short_name = data["short_name"]
report.owner_id = get_login_user().user_id # !+GROUP_AS_OWNER
report.language = get_default_language()
report.created_date = datetime.datetime.now()
if not hasattr(self.context, "group_id"):
report.group_id = ISchedulingContext(self.context).group_id
else:
report.group_id = self.context.group_id
session.add(report)
session.flush()
notify(ObjectCreatedEvent(report))
if "sittings" in data.keys():
try:
ids = data["sittings"].split(",")
for id_number in ids:
sit_id = int(id_number)
sitting = session.query(domain.Sitting).get(sit_id)
sr = domain.SittingReport()
sr.report = report
sr.sitting = sitting
session.add(sr)
notify(ObjectCreatedEvent(report))
except:
#if no sittings are present in report or some other error occurs
pass
session.flush()
if ISitting.providedBy(self.context):
back_link = "./schedule"
else:
back_link = "./"
self.request.response.redirect(back_link)
def __call__(self):
date = datetime.datetime.strptime(self.request.form['date'],
'%Y-%m-%d').date()
self.display_minutes = (self.request.form['display_minutes'] == "True")
time_span = self.request.form['time_span']
if time_span == TIME_SPAN.daily:
time_span = TIME_SPAN.daily
elif time_span == TIME_SPAN.weekly:
time_span = TIME_SPAN.weekly
end = self.get_end_date(date, time_span)
body_text = super(StoreReportView, self).__call__()
sitting_items = []
for sitting in self.sitting_items:
if self.display_minutes:
if sitting.status in ["published-minutes"]:
sitting_items.append(sitting)
else:
if sitting.status in [
"published-agenda", "draft-minutes",
"published-minutes"
]:
sitting_items.append(sitting)
if len(sitting_items) == 0:
referer = self.request.getHeader('HTTP_REFERER')
if referer:
referer = referer.split('?')[0]
else:
referer = ""
self.request.response.redirect(
referer + "?portal_status_message=No data found")
return
self.sitting_items = sitting_items
session = Session()
report = domain.Report()
report.start_date = date
report.end_date = end
report.created_date = datetime.datetime.now()
if self.display_minutes:
report.report_type = 'minutes'
else:
report.report_type = 'agenda'
report.body_text = body_text
report.user_id = get_principal_id()
report.group_id = self.group.group_id
session.add(report)
for sitting in self.sitting_items:
sr = domain.SittingReport()
sr.report = report
sr.sitting = sitting
session.add(sr)
session.flush()
rpm = zope.securitypolicy.interfaces.IRolePermissionMap(report)
rpm.grantPermissionToRole(u'zope.View', 'bungeni.Anybody')
if IGroupSitting.providedBy(self.context):
back_link = ui_url.absoluteURL(self.context,
self.request) + '/schedule'
elif ISchedulingContext.providedBy(self.context):
back_link = ui_url.absoluteURL(self.context, self.request)
else:
raise NotImplementedError
self.request.response.redirect(back_link)
session.close()
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))
