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 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 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))