def loadConfiguration(self):
"""Process report template for configuration
"""
if os.path.exists(self.report_template_file):
template_file = open(self.report_template_file)
file_string = template_file.read()
self.report_template = etree.fromstring(file_string)
template_file.close()
self.title = get_config(self.report_template, "title", self.title)
self.language = get_config(self.report_template, "language",
get_default_language()
)
coverage_text = get_config(self.report_template, "length")
if coverage_text is not None:
self.coverage = report_tools.compute_hours(coverage_text)
drop_element(
self.report_template.find("{%s}config" % BUNGENI_REPORTS_NS)
)
else:
raise ReportException(
_(u"report-template-missing",
default=u"Report template file does not exist at ${path}",
mapping={"path": self.report_template_file}
)
)
def saveDiscussions(self):
session = Session()
new_record_keys = []
domain_model = removeSecurityProxy(self.context.domain_model)
for record in self.data:
discussion_text = record.get("body", "")
object_id = record.get("object_id", None)
if object_id:
current_record = removeSecurityProxy(self.context.get(getItemKey(object_id)))
current_record.body = discussion_text
session.add(current_record)
session.flush()
notify(ObjectModifiedEvent(current_record))
new_record_keys.append(stringKey(current_record))
else:
new_record = domain_model(body=discussion_text, language=get_default_language())
new_record.scheduled_item = removeSecurityProxy(self.context.__parent__)
session.add(new_record)
session.flush()
notify(ObjectCreatedEvent(new_record))
new_record_keys.append(stringKey(new_record))
records_to_delete = [
removeSecurityProxy(self.context.get(key)) for key in self.context.keys() if key not in new_record_keys
]
map(session.delete, records_to_delete)
map(lambda deleted: notify(ObjectRemovedEvent(deleted)), records_to_delete)
def __call__(self, context=None):
all_terms = self.vdex.getVocabularyDict(lang=get_default_language())
terms = []
assert self.vdex.isFlat() is True
for (key, data) in all_terms.iteritems():
term = vocabulary.SimpleTerm(key, key, data[0])
terms.append(term)
return vocabulary.SimpleVocabulary(terms)
def translate_objects(self, nodes, lang=None):
""" Translate container items if translatable
"""
if lang is None:
lang = get_default_language()
for index, node in enumerate(nodes):
if ITranslatable.providedBy(node):
nodes[index] = translation.translated(node, lang)
return nodes
def translate_objects(self, nodes, lang=None):
"""Translate container items if context domain is translatable
"""
if not mfaces.ITranslatable.implementedBy(self.domain_model):
return nodes
# !+ lang should always be valid here... make not optional, assert?
if lang is None:
lang = get_default_language()
return [translation.translated(node, lang) for node in nodes]
def __call__(self):
if not self.has_value:
return "<span>%s</span>" %(_(u"no subjects"))
lang = get_default_language()
term_texts = [
self.context.vocabulary.getTermCaptionById(data_value, lang)
for data_value in self._data.split("\n")
]
return "<ul>%s</ul>" % (
"".join([ "<li>%s</li>" % (t) for t in term_texts ]))
def translate(msgid, **kwargs):
"""Translate msgid from catalogs using default domain if none provided.
API: zope.i18n.translate(msgid, domain=None,
mapping=None, context=None, target_language=None, default=None)
"""
if kwargs.get("domain", None) is None:
kwargs["domain"] = domain
if kwargs.get("target_language", None) is None:
from bungeni.core.language import get_default_language
kwargs["target_language"] = get_default_language() or capi.default_language
return zope.i18n.translate(msgid, **kwargs)
def translate(self, context, name):
"""Gets translated field values
"""
lang = get_default_language()
if not lang:
return getattr(context, name, "")
if interfaces.ITranslatable.providedBy(context):
if context.language != lang:
translation = get_field_translations(context, lang)
if translation:
translation = filter(lambda tr:tr.field_name==name,
translation)
if translation[0].field_text:
return translation[0].field_text
return getattr(context, name)
def expand_containers(self, items, containers, _url, chain=(), context=None):
#seen_context = False
_url = _url.rstrip("/")
current = False
for key, container in containers:
assert IAlchemistContainer.providedBy(container)
# do not include doc containers for docs who do not specifically
# declare the parent group instance as a workspace.group_name
if IDoc.implementedBy(container.domain_model):
group = get_group_for_context(container)
assert IGroup.providedBy(group)
doc_type_key = naming.polymorphic_identity(container.domain_model)
if not group.is_type_workspaced(doc_type_key):
continue
label = container.domain_model.__name__
descriptor = utils.get_descriptor(container.domain_model)
order = 999
if descriptor:
order = descriptor.order
label = getattr(descriptor, "container_name", None) or \
getattr(descriptor, "display_name", None)
if context is not None:
current = container.__name__ == context.__name__
selected = not len(chain) and current
if current:
#seen_context = True
nodes = self.expand(chain)
else:
nodes = ()
key_url = "%s/%s" % (_url, key)
items.append({
"id": self.get_nav_entry_id(key_url),
"order": order,
"label": translate(label,
target_language=get_default_language(),
domain="bungeni"),
"url": key_url,
"current": current,
"selected": selected,
"kind": "container",
"nodes": nodes,
})
items.sort(key=lambda item:(item['order'], item['label']))
def setUpWidgets(self, ignore_request=False):
languages = get_all_languages()
self.form_fields = filterFields(self.context, self.form_fields)
# do not display empty form fields
omit_names = []
for f in self.form_fields:
val = getattr(self.context, f.__name__)
if val is None:
omit_names.append(f.__name__)
self.form_fields = self.form_fields.omit(*omit_names)
context = self.context
if ITranslatable.providedBy(self.context):
lang = get_default_language()
try:
translation = get_field_translations(self.context, lang)
except:
translation = []
if (
not translation
and getattr(self.context, "language", None)
and getattr(self.context, "language", None) != lang
):
supported_lang = languages.get(lang)
if supported_lang:
langname = supported_lang.get("native", None)
if langname == None:
langname = supported_lang.get("name")
self.status = translate(
_(u"This content is not yet translated into" + " $language", mapping={"language": langname}),
domain="bungeni",
context=self.request,
)
context = copy(removeSecurityProxy(self.context))
for field_translation in translation:
setattr(context, field_translation.field_name, field_translation.field_text)
self.widgets = form.setUpEditWidgets(
self.form_fields,
"",
context,
self.request,
adapters=self.adapters,
for_display=True,
ignore_request=ignore_request,
)
def translation_status(self):
if ITranslatable.providedBy(self.context) and len(capi.pivot_languages):
untranslated = list(capi.pivot_languages)
if self.context.language in untranslated:
untranslated.remove(self.context.language)
for pivot_lang in untranslated:
if translation.get_field_translations(self.context, pivot_lang):
untranslated.remove(pivot_lang)
if len(untranslated):
i18n_langs = []
locale = locales.getLocale(get_default_language().split("-")[0], None)
for lang in untranslated:
if locale and locale.displayNames and locale.displayNames.languages:
i18n_langs.append(locale.displayNames.languages.get(lang, lang))
continue
i18n_langs.append(lang)
return ", ".join(i18n_langs)
return translate(_("translated"), context=get_request())
return translate("n/a", context=get_request())
def translated(context, lang=None):
"""Translate an ITranslatable content object (context, that may NOT be None)
into the specified language or that defined in the request
-> copy of the object translated into language of the request
"""
if lang is None:
lang = get_default_language()
# only translate if needed i.e. if target language is other than context's original
if context.language == lang:
return context
# ok, translate...
# !+TRANSLATED mark translated obj with the translation lang?
# plus, is it ok to translate object then get an attr that triggers
# dynamic SA/db requests?
obj = copy(removeSecurityProxy(context))
field_translations = get_field_translations(context, lang)
for field_translation in field_translations:
setattr(obj, field_translation.field_name, field_translation.field_text)
return obj
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.flush()
notify(ObjectCreatedEvent(sr))
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.short_name = data["short_name"]
report.owner_id = get_db_user_id()
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.GroupSitting).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 IGroupSitting.providedBy(self.context):
back_link = "./schedule"
else:
back_link = "./"
self.request.response.redirect(back_link)
def render(self, template=None):
need("dhtmlxscheduler")
need("dhtmlxscheduler-recurring")
if template is None:
template = self.template
if (not checkPermission(u"bungeni.sitting.Add", self.context)) or \
(IBusinessSectionLayer.providedBy(self.request)):
self.edit = False
else:
self.edit = True
session = Session()
venues = session.query(domain.Venue).all()
languages = get_all_languages()
# !+SESSION_CLOSE(taras.sterch, july-2011) there is no need to close the
# session. Transaction manager will take care of this. Hope it does not
# brake anything.
#session.close()
self.display_language = get_default_language()
if self.request.get("I18N_LANGUAGE"):
self.display_language = self.request.get("I18N_LANGUAGE")
#html is hardcoded in here because doing it in the template
#would have been a colossal pain
#TODO: FIX THIS
s = '<div class="dhx_cal_ltext" style="height:90px;">'
s += '<table>'
s += '<tr><td>Venue</td><td><select id="select_sitting_venue">'
for venue in venues:
s += '<option value="'+str(venue.venue_id)+'">'+venue.short_name+'</option>'
s += '</select></td></tr>'
s += '<tr><td>Language</td><td><select id="select_sitting_lang">'
for lang in languages:
if lang == 'en':
s += '<option value="'+lang+'" selected>'+lang+'</option>'
else:
s += '<option value="'+lang+'">'+lang+'</option>'
s += '</select></td></tr></table></div>'
self.sitting_details_form = s
return template()
def update(self):
def css_class(language):
css_attr = None
if language == selected:
css_attr = "selected"
if language in translations:
if css_attr:
css_attr = css_attr + " available"
else:
css_attr = "available"
return css_attr
def language_name(language):
return language.get("native", language.get("name"))
translations = get_available_translations(self.context)
if hasattr(self.context, "language"):
translations[self.context.language] = None
languages = get_all_languages()
selected = normalize_lang(get_default_language())
url = ui_utils.url.absoluteURL(getSite(), self.request)
self.languages = sorted([
{
"code": language,
"flag": url+languages[language].get('flag', ''),
"name": language_name(languages[language]),
"css_class": css_class(language),
"url": "%s/change-language?language=%s" % (
url, language
),
}
for language in languages
],
key=lambda l:l.get("code")
)
def __call__(self):
start, limit = self.get_offsets() # ? start=0&limit=25
lang = get_default_language()
return self.json_batch(start, limit, lang)
def getDefaultVocabularyValue(self):
return get_default_language()
def saveSchedule(self):
session = Session()
group_sitting_id = self.sitting.group_sitting_id
group_id = self.sitting.group_id
record_keys = []
for (index, data_item_text) in enumerate(self.data):
data_item = json.loads(data_item_text)
actual_index = index + 1
data_schedule_id = data_item.get("schedule_id")
data_item_id = data_item.get("item_id")
data_item_type = data_item.get("item_type")
data_item_text = data_item.get("item_text")
if not data_item_id:
# create text record before inserting into schedule
if data_item_type == u"text":
text_record = domain.ScheduleText(
text=data_item_text,
group_id=group_id,
language=get_default_language()
)
session.add(text_record)
session.flush()
notify(ObjectCreatedEvent(text_record))
data_item_id = text_record.schedule_text_id
elif data_item_type == u"heading":
heading_record = domain.Heading(
text=data_item_text,
group_id=group_id,
language=get_default_language()
)
session.add(heading_record)
session.flush()
notify(ObjectCreatedEvent(heading_record))
data_item_id = heading_record.heading_id
schedule_record = domain.ItemSchedule(
item_id=data_item_id,
item_type=data_item_type,
planned_order=actual_index,
group_sitting_id=group_sitting_id
)
session.add(schedule_record)
session.flush()
notify(ObjectCreatedEvent(schedule_record))
else:
if data_schedule_id:
current_record = removeSecurityProxy(
self.context.get(getItemKey(data_schedule_id))
)
current_record.planned_order = actual_index
session.add(current_record)
session.flush()
notify(ObjectModifiedEvent(current_record))
#update text for text records
#!+INTERFACES(Apply this behaviour via shared interface)
if data_item_type in [u"text", u"heading"]:
text_record = removeSecurityProxy(current_record.item)
if text_record.text != data_item_text:
text_record.text = data_item_text
session.add(text_record)
session.flush()
notify(ObjectModifiedEvent(text_record))
else:
schedule_record = domain.ItemSchedule(
item_id=data_item_id,
item_type=data_item_type,
planned_order=actual_index,
group_sitting_id=group_sitting_id
)
session.add(schedule_record)
session.flush()
notify(ObjectCreatedEvent(schedule_record))
record_keys.append(self.RECORD_KEY % (data_item_type, data_item_id))
records_to_delete = filter(
lambda item:(self.RECORD_KEY % (item.item_type, item.item_id)
not in record_keys
),
[removeSecurityProxy(rec) for rec in self.context.values()]
)
map(session.delete, records_to_delete)
map(lambda deleted:notify(ObjectRemovedEvent(deleted)),
records_to_delete
)
def __call__(self):
# prepare required parameters
start, limit = self.get_offsets() # ? start=0&limit=25
lang = get_default_language()
return self.json_batch(start, limit, lang)
def __init__(self, *args):
super(TranslateForm, self).__init__(*args)
self.language = self.request.get("language", get_default_language())
def saveSchedule(self):
session = Session()
sitting_id = self.sitting.sitting_id
record_keys = []
planned_index = 1
def add_planned_index(obj, index):
"""add planned order key for non text record types
"""
if not (model_interfaces.IScheduleText.providedBy(obj.item)):
obj.planned_order = planned_index
index = index + 1
return index
for (index, data_item) in enumerate(self.data):
real_index = index + 1
data_schedule_id = data_item.get("schedule_id")
data_item_id = data_item.get("item_id")
data_item_type = data_item.get("item_type")
schedule_item_type = data_item_type
data_item_text = data_item.get("item_text")
data_item_wf_status = data_item.get("wf_status")
if not data_item_id:
# create text record before inserting into schedule
text_record = domain.AgendaTextRecord(
text=data_item_text,
record_type=data_item_type,
language=get_default_language())
session.add(text_record)
session.flush()
notify(ObjectCreatedEvent(text_record))
data_item_id = domain.get_mapped_object_id(text_record)
schedule_item_type = domain.AgendaTextRecord.type
schedule_record = domain.ItemSchedule(
item_id=data_item_id,
item_type=schedule_item_type,
real_order=real_index,
sitting_id=sitting_id)
session.add(schedule_record)
session.flush()
notify(ObjectCreatedEvent(schedule_record))
else:
if data_schedule_id:
current_record = removeSecurityProxy(
self.context.get(getItemKey(data_schedule_id)))
current_record.real_order = real_index
planned_index = add_planned_index(current_record,
planned_index)
session.add(current_record)
session.flush()
notify(ObjectModifiedEvent(current_record))
#workflow operations
wfc = IWorkflowController(current_record.item, None)
if wfc:
if wfc and data_item_wf_status:
try:
wfc.workflow.get_transition(
data_item_wf_status)
wfc.fireTransition(data_item_wf_status)
except InvalidTransitionError:
log.error(
"Invalid transition [%s] for object: [%s] ",
data_item_wf_status, current_record)
wfc.fireAutomatic()
# update text for text records
text_record = removeSecurityProxy(current_record.item)
if model_interfaces.IScheduleText.providedBy(text_record):
schedule_item_type = domain.AgendaTextRecord.type
if text_record.text != data_item_text:
text_record.text = data_item_text
session.add(text_record)
session.flush()
notify(ObjectModifiedEvent(text_record))
else:
schedule_record = domain.ItemSchedule(
item_id=data_item_id,
item_type=data_item_type,
real_order=real_index,
sitting_id=sitting_id)
planned_index = add_planned_index(schedule_record,
planned_index)
session.add(schedule_record)
session.flush()
notify(ObjectCreatedEvent(schedule_record))
record_keys.append(self.RECORD_KEY %
(schedule_item_type, data_item_id))
records_to_delete = filter(
lambda item: (self.RECORD_KEY %
(item.item_type, item.item_id) not in record_keys),
[removeSecurityProxy(rec) for rec in self.context.values()])
map(session.delete, records_to_delete)
map(lambda deleted: notify(ObjectRemovedEvent(deleted)),
records_to_delete)
def __init__(self, *args, **kwargs):
super(DhtmlxSchedulerMainLanguage, self).__init__(*args, **kwargs)
self.language = get_default_language()
self._path = self.setPath()
def __call__(self):
start, limit = self.get_offsets() # ? start=0&limit=25
lang = get_default_language()
return self.json_batch(start, limit, lang)
def __init__(self, *args, **kwargs):
super(DhtmlxSchedulerMainLanguage, self).__init__(*args, **kwargs)
self.language = get_default_language()
self._path = self.setPath()
def __init__(self, *args):
super(TranslateForm, self).__init__(*args)
self.language = self.request.get("language", get_default_language())
def getDefaultVocabularyValue(self):
return get_default_language()
def saveSchedule(self):
session = Session()
sitting_id = self.sitting.sitting_id
record_keys = []
planned_index = 1
def add_planned_index(obj, index):
"""add planned order key for non text record types
"""
if not (model_interfaces.IScheduleText.providedBy(obj.item)):
obj.planned_order = planned_index
index = index + 1
return index
for (index, data_item) in enumerate(self.data):
real_index = index + 1
data_schedule_id = data_item.get("schedule_id")
data_item_id = data_item.get("item_id")
data_item_type = data_item.get("item_type")
schedule_item_type = data_item_type
data_item_text = data_item.get("item_text")
data_item_wf_status = data_item.get("wf_status")
if not data_item_id:
# create text record before inserting into schedule
text_record = domain.AgendaTextRecord(
text=data_item_text,
record_type = data_item_type,
language=get_default_language()
)
session.add(text_record)
session.flush()
notify(ObjectCreatedEvent(text_record))
data_item_id = domain.get_mapped_object_id(text_record)
schedule_item_type = domain.AgendaTextRecord.type
schedule_record = domain.ItemSchedule(
item_id=data_item_id,
item_type=schedule_item_type,
real_order=real_index,
sitting_id=sitting_id
)
session.add(schedule_record)
session.flush()
notify(ObjectCreatedEvent(schedule_record))
else:
if data_schedule_id:
current_record = removeSecurityProxy(
self.context.get(getItemKey(data_schedule_id))
)
current_record.real_order = real_index
planned_index = add_planned_index(current_record,
planned_index)
session.add(current_record)
session.flush()
notify(ObjectModifiedEvent(current_record))
#workflow operations
wfc = IWorkflowController(current_record.item, None)
if wfc:
if wfc and data_item_wf_status:
try:
wfc.workflow.get_transition(data_item_wf_status)
wfc.fireTransition(data_item_wf_status)
except InvalidTransitionError:
log.error(
"Invalid transition [%s] for object: [%s] ",
data_item_wf_status, current_record
)
wfc.fireAutomatic()
#update text for text records
text_record = removeSecurityProxy(current_record.item)
if model_interfaces.IScheduleText.providedBy(text_record):
schedule_item_type = domain.AgendaTextRecord.type
if text_record.text != data_item_text:
text_record.text = data_item_text
session.add(text_record)
session.flush()
notify(ObjectModifiedEvent(text_record))
else:
schedule_record = domain.ItemSchedule(
item_id=data_item_id,
item_type=data_item_type,
real_order=real_index,
sitting_id=sitting_id
)
planned_index = add_planned_index(schedule_record,
planned_index)
session.add(schedule_record)
session.flush()
notify(ObjectCreatedEvent(schedule_record))
record_keys.append(self.RECORD_KEY %
(schedule_item_type, data_item_id))
records_to_delete = filter(
lambda item:(self.RECORD_KEY % (item.item_type, item.item_id)
not in record_keys
),
[removeSecurityProxy(rec) for rec in self.context.values()]
)
map(session.delete, records_to_delete)
map(lambda deleted:notify(ObjectRemovedEvent(deleted)),
records_to_delete)
def __init__(self, *args):
# !+view/viewlet(mr, jul-2011)
super(TranslateForm, self).__init__(*args)
self.language = self.request.get("language", get_default_language())
def generateJSON(self, selected = []):
vdict = self.vdex.getVocabularyDict(lang=get_default_language())
dynatree_dict = dict_to_dynatree(vdict, selected)
return json.dumps(dynatree_dict)
def generateJSON(self, selected=[]):
vdict = self.vdex.getVocabularyDict(lang=get_default_language())
dynatree_dict = dict_to_dynatree(vdict, selected)
return json.dumps(dynatree_dict)
def __init__(self, *args):
# !+view/viewlet(mr, jul-2011)
super(TranslateForm, self).__init__(*args)
self.language = self.request.get("language", get_default_language())
def publishTraverse(self, request, name):
request.response.setHeader("Content-type", RESOURCE_HEADERS.get(name, "text/javascript"))
self.request = request
self.language = get_default_language()
return getattr(self, RESOURCE_MAPPING.get(name))
