354 lines
12 KiB
Python
354 lines
12 KiB
Python
# -*- coding: utf-8 -*-
|
|
|
|
from zope import component
|
|
from zope.browser.interfaces import ITerms
|
|
from zope.interface import implements, classProvides
|
|
from zope.schema.interfaces import ISource, IContextSourceBinder
|
|
|
|
from zope.app.form.browser.interfaces import ISourceQueryView
|
|
|
|
from zope.schema.interfaces import IVocabularyFactory
|
|
from zope.schema.vocabulary import SimpleVocabulary, SimpleTerm
|
|
|
|
from Products.CMFCore.utils import getToolByName
|
|
|
|
from plone.registry.interfaces import IRegistry
|
|
from plone.formwidget.contenttree import ObjPathSourceBinder
|
|
from plone.formwidget.contenttree.source import ObjPathSource
|
|
|
|
try:
|
|
from tabellio.config.interfaces import ITabellioSettings
|
|
except ImportError:
|
|
ITabellioSettings = None
|
|
|
|
|
|
class CommissionsSource(object):
|
|
implements(IContextSourceBinder)
|
|
|
|
def __init__(self):
|
|
pass
|
|
|
|
def __call__(self, context):
|
|
catalog = getToolByName(context, 'portal_catalog')
|
|
results = catalog(portal_type='themis.datatypes.commission')
|
|
commissions = sorted([x.getObject().title for x in results])
|
|
terms = [SimpleVocabulary.createTerm(x, x.encode('ascii', 'replace'), x) for x in commissions]
|
|
return SimpleVocabulary(terms)
|
|
|
|
def __iter__(self):
|
|
# hack to let schema editor handle the field
|
|
yield u'DO NOT TOUCH'
|
|
|
|
|
|
def cmp_person(x, y):
|
|
t = cmp(x.lastname.lower(), y.lastname.lower())
|
|
if t: return t
|
|
return cmp(x.firstname.lower(), y.lastname.lower())
|
|
|
|
def get_terms_for_persons(context, include_deputies=False,
|
|
include_ministries=False, include_ministries_collaborators=False):
|
|
catalog = getToolByName(context, 'portal_catalog')
|
|
|
|
if include_deputies:
|
|
results = catalog(portal_type='themis.datatypes.deputy')
|
|
deputies = [x.getObject() for x in results]
|
|
else:
|
|
deputies = []
|
|
|
|
if include_ministries:
|
|
results = catalog(portal_type='themis.datatypes.ministry')
|
|
ministries = [x.getObject() for x in results]
|
|
else:
|
|
ministries = []
|
|
|
|
list = []
|
|
if include_deputies:
|
|
list.extend(deputies)
|
|
if include_ministries:
|
|
list.extend(ministries)
|
|
|
|
list.sort(cmp_person)
|
|
|
|
terms = []
|
|
for person in list:
|
|
if person in deputies:
|
|
prefix = 'deputy'
|
|
if person.polgroup:
|
|
label = '%s %s (%s)' % (person.lastname, person.firstname, person.polgroup.to_object.title)
|
|
else:
|
|
label ='%s %s (?)' % (person.lastname, person.firstname)
|
|
else:
|
|
prefix = 'ministry'
|
|
label = '%s %s (ministre)' % (person.lastname, person.firstname)
|
|
|
|
terms.append(SimpleVocabulary.createTerm(
|
|
'%s:%s' % (prefix, person.id),
|
|
'%s:%s' % (prefix, person.id),
|
|
label))
|
|
|
|
if include_ministries_collaborators:
|
|
results = catalog(portal_type='themis.datatypes.ministry')
|
|
ministries = [x.getObject() for x in results]
|
|
ministries.sort(cmp_person)
|
|
for person in ministries:
|
|
terms.append(SimpleVocabulary.createTerm(
|
|
'ministry-collab:%s' % person.id,
|
|
'ministry-collab:%s' % person.id,
|
|
'Collaborateur du Ministre %s %s' % (person.firstname, person.lastname)))
|
|
|
|
return terms
|
|
|
|
|
|
class DeputiesSource(object):
|
|
implements(IContextSourceBinder)
|
|
|
|
def __call__(self, context):
|
|
return SimpleVocabulary(get_terms_for_persons(context, include_deputies=True))
|
|
|
|
def __iter__(self):
|
|
# hack to let schema editor handle the field
|
|
yield u'DO NOT TOUCH'
|
|
|
|
|
|
class MinistriesSource(object):
|
|
implements(IContextSourceBinder)
|
|
|
|
def __call__(self, context):
|
|
college_term = [SimpleVocabulary.createTerm(
|
|
'ministry:college','ministry:college', u'Collège')]
|
|
return SimpleVocabulary(get_terms_for_persons(context, include_ministries=True) + college_term)
|
|
|
|
def __iter__(self):
|
|
# hack to let schema editor handle the field
|
|
yield u'DO NOT TOUCH'
|
|
|
|
|
|
class DeputiesAndMinistriesSource(object):
|
|
implements(IContextSourceBinder)
|
|
|
|
def __init__(self):
|
|
pass
|
|
|
|
def __call__(self, context):
|
|
college_term = [SimpleVocabulary.createTerm(
|
|
'ministry:college','ministry:college', u'Collège')]
|
|
return SimpleVocabulary(get_terms_for_persons(context,
|
|
include_deputies=True, include_ministries=True) + college_term)
|
|
|
|
def __iter__(self):
|
|
# hack to let schema editor handle the field
|
|
yield u'DO NOT TOUCH'
|
|
|
|
|
|
class ContactsVocabulary(SimpleVocabulary):
|
|
context = None
|
|
|
|
def __init__(self, context, contact_ids, *args, **kwargs):
|
|
self.context = context
|
|
self.contact_ids = contact_ids
|
|
super(ContactsVocabulary, self).__init__(*args, **kwargs)
|
|
|
|
def getTermByToken(self, token):
|
|
try:
|
|
return super(ContactsVocabulary, self).getTermByToken(token)
|
|
except LookupError:
|
|
if not token:
|
|
raise
|
|
if token.startswith('contact:'):
|
|
raise
|
|
|
|
# a simple string, create a contact object to match
|
|
portal = getToolByName(self.context, 'portal_url').getPortalObject()
|
|
plone_tool = getToolByName(self.context, 'plone_utils')
|
|
new_id = plone_tool.normalizeString(token)
|
|
if not portal.contacts.has_key(new_id):
|
|
portal.contacts.invokeFactory(
|
|
'themis.datatypes.contact', new_id, title=token)
|
|
|
|
return self.createTerm('contact:'+new_id, 'contact:' + new_id, token)
|
|
|
|
def search(self, qs):
|
|
q = qs.lower()
|
|
t = [self.by_value.get('contact:'+kw) for kw in self.contact_ids if q in kw.lower()]
|
|
return t
|
|
|
|
|
|
class ContactsSource(object):
|
|
implements(IContextSourceBinder)
|
|
|
|
def __init__(self):
|
|
pass
|
|
|
|
def fastGetTitleByToken(self, context, token):
|
|
if not ':' in token:
|
|
return token
|
|
if token == 'ministry:college':
|
|
return u'Collège'
|
|
prefix, value = token.split(':')
|
|
portal = getToolByName(context, 'portal_url').getPortalObject()
|
|
if prefix == 'deputy':
|
|
url = 'deputes'
|
|
elif prefix in ('ministry', 'ministry-collab'):
|
|
url = 'ministres'
|
|
elif prefix == 'contact':
|
|
url = 'contacts'
|
|
else:
|
|
raise KeyError(token)
|
|
try:
|
|
return getattr(getattr(portal, url), value).Title()
|
|
except AttributeError:
|
|
raise KeyError(token)
|
|
|
|
def __call__(self, context):
|
|
catalog = getToolByName(context, 'portal_catalog')
|
|
|
|
depmin_terms = get_terms_for_persons(context,
|
|
include_deputies=True, include_ministries=True)
|
|
college_term = [SimpleVocabulary.createTerm(
|
|
'ministry:college','ministry:college', u'Collège')]
|
|
|
|
results = catalog(portal_type='themis.datatypes.contact')
|
|
contacts = [x.getObject() for x in results]
|
|
def cmp_contact(x, y):
|
|
return cmp(x.title, y.title)
|
|
contacts.sort(cmp_contact)
|
|
contact_ids = [x.id for x in contacts]
|
|
contacts_terms = [SimpleVocabulary.createTerm(
|
|
'contact:'+x.id, 'contact:'+x.id, x.title) for x in contacts]
|
|
return ContactsVocabulary(context, contact_ids, depmin_terms + college_term + contacts_terms)
|
|
|
|
def __iter__(self):
|
|
# hack to let schema editor handle the field
|
|
yield u'DO NOT TOUCH'
|
|
|
|
|
|
class SpeakersSource(object):
|
|
implements(IContextSourceBinder)
|
|
|
|
def __init__(self):
|
|
pass
|
|
|
|
def __call__(self, context):
|
|
extra_terms = [SimpleVocabulary.createTerm(
|
|
'speaker:cour-des-comptes', 'speaker:cour-des-comptes', u'Cour des comptes'),
|
|
SimpleVocabulary.createTerm(
|
|
'speaker:huis-clos', 'speaker:huis-clos', u'Orateur(s) à huis clos')]
|
|
return SimpleVocabulary(get_terms_for_persons(context,
|
|
include_deputies=True,
|
|
include_ministries=True,
|
|
include_ministries_collaborators=True) + extra_terms)
|
|
|
|
def __iter__(self):
|
|
# hack to let schema editor handle the field
|
|
yield u'DO NOT TOUCH'
|
|
|
|
|
|
|
|
class SubjectsSource(object):
|
|
implements(IContextSourceBinder)
|
|
|
|
def __init__(self):
|
|
# XXX get this list from the catalog
|
|
self.terms = [
|
|
u"Action sociale",
|
|
u"Budget",
|
|
u"Budget du PFB",
|
|
u"Cohésion sociale",
|
|
u"Compétences résiduaires",
|
|
u"Compte du PFB",
|
|
u"Coordination de la politique du Collège",
|
|
u"Culture",
|
|
u"Enseignement",
|
|
u"Famille",
|
|
u"Fonction publique / administration",
|
|
u"Formation professionnelle",
|
|
u"Politique d'aide aux personnes handicapées",
|
|
u"Règlement du PFB",
|
|
u"Relations internationales",
|
|
u"Santé",
|
|
u"Sport",
|
|
u"Tourisme",
|
|
u"Transport scolaire",
|
|
]
|
|
|
|
def __call__(self, context):
|
|
terms = [SimpleVocabulary.createTerm(x, x.encode('ascii', 'replace'), x) for x in self.terms]
|
|
return SimpleVocabulary(terms)
|
|
|
|
def __iter__(self):
|
|
# hack to let schema editor handle the field
|
|
yield u'DO NOT TOUCH'
|
|
|
|
|
|
class LegislativeSessionsSource(object): # Legislative sessions
|
|
implements(IContextSourceBinder)
|
|
|
|
def __init__(self):
|
|
self.terms = None
|
|
|
|
def _setup(self):
|
|
if self.terms:
|
|
return
|
|
|
|
if ITabellioSettings:
|
|
settings = component.getUtility(IRegistry).forInterface(ITabellioSettings, False)
|
|
sessions = settings.sessions
|
|
if sessions:
|
|
self.terms = [x.split(':')[1].strip() for x in sessions.splitlines() if x]
|
|
return
|
|
|
|
# fallback to an hardcoded list
|
|
self.terms = [
|
|
u"2010 - 2011",
|
|
u"2009 - 2010",
|
|
u"Session Ordinaire 2009",
|
|
u"2008 - 2009",
|
|
u"2007 - 2008",
|
|
u"2006 - 2007",
|
|
u"2005 - 2006",
|
|
u"2004 - 2005",
|
|
u"Session Extraordinaire 2004",
|
|
u"2003 - 2004",
|
|
u"2002 - 2003",
|
|
u"2001 - 2002",
|
|
u"2000 - 2001",
|
|
u"1999 - 2000",
|
|
u"Session Extraordinaire 1999",
|
|
u"1998 - 1999",
|
|
u"1997 - 1998",
|
|
u"1996 - 1997",
|
|
u"1995 - 1996",
|
|
u"1994 - 1995",
|
|
u"1993 - 1994",
|
|
u"1992 - 1993",
|
|
u"1991 - 1992",
|
|
u"1990 - 1991",
|
|
u"1989 - 1990",
|
|
]
|
|
|
|
def __call__(self, context):
|
|
self._setup()
|
|
terms = [SimpleVocabulary.createTerm(x, x.encode('ascii', 'replace'), x) for x in self.terms]
|
|
return SimpleVocabulary(terms)
|
|
|
|
def __iter__(self):
|
|
# hack to let schema editor handle the field
|
|
yield u'DO NOT TOUCH'
|
|
|
|
class RelatedDocObjPathSource(ObjPathSource):
|
|
def getTermByBrain(self, brain, real_value=True):
|
|
if real_value:
|
|
value = brain._unrestrictedGetObject()
|
|
else:
|
|
value = brain.getPath()[len(self.portal_path):]
|
|
return SimpleTerm(value, token=brain.getPath(), title=u'%s [%s]' % (
|
|
unicode(brain.Title, 'utf-8'),
|
|
brain.getObject().Type()))
|
|
|
|
class RelatedDocObjPathSourceBinder(ObjPathSourceBinder):
|
|
path_source = RelatedDocObjPathSource
|
|
|
|
def __iter__(self):
|
|
# hack to let schema editor handle the field
|
|
yield u'DO NOT TOUCH'
|