1045 lines
40 KiB
Python
1045 lines
40 KiB
Python
# -*- coding: utf-8 -*-
|
|
|
|
import re
|
|
import time
|
|
import datetime
|
|
|
|
from five import grok
|
|
from plone.memoize import instance, ram
|
|
from zope import interface, schema, component
|
|
from z3c.form import form, field, button
|
|
from plone.z3cform.layout import wrap_form
|
|
from Products.CMFCore.utils import getToolByName
|
|
from zope.interface import implements
|
|
|
|
from z3c.form.ptcompat import ViewPageTemplateFile
|
|
import z3c.form.interfaces
|
|
from z3c.form.browser import text
|
|
from z3c.form import widget
|
|
from z3c.form.interfaces import ITextWidget
|
|
from z3c.form.browser.checkbox import CheckBoxWidget
|
|
from z3c.form.browser.radio import RadioWidget
|
|
|
|
from z3c.relationfield.schema import RelationChoice, RelationList
|
|
from plone.formwidget.contenttree import ObjPathSourceBinder
|
|
import plone.directives.form
|
|
|
|
from tabellio.searchform.interfaces import MessageFactory as _
|
|
|
|
import Missing
|
|
|
|
from Products.Five import BrowserView
|
|
from Products.Five.browser.pagetemplatefile import ViewPageTemplateFile
|
|
from zope.schema.interfaces import IContextSourceBinder
|
|
from zope.schema.vocabulary import SimpleVocabulary, SimpleTerm
|
|
|
|
from plone.registry.interfaces import IRegistry
|
|
|
|
from tabellio.config.interfaces import ITabellioSettings
|
|
import tabellio.config.utils
|
|
from tabellio.documents.typenames import MAPPING
|
|
|
|
|
|
class ListAuthorsView(BrowserView):
|
|
def get_folder_at_path(self, path):
|
|
current = self.portal
|
|
for part in path.split('/'):
|
|
if not part:
|
|
continue
|
|
current = getattr(current, part)
|
|
return current
|
|
|
|
_deputies_folder = None
|
|
def deputies_folder(self):
|
|
if self._deputies_folder:
|
|
return self._deputies_folder
|
|
path = self.settings.deputiesPath
|
|
self._deputies_folder = self.get_folder_at_path(path)
|
|
return self._deputies_folder
|
|
deputies_folder = property(deputies_folder)
|
|
|
|
def __call__(self):
|
|
from plone.i18n.normalizer.fr import normalizer
|
|
|
|
self.portal = getToolByName(self.context, 'portal_url').getPortalObject()
|
|
self.settings = component.getUtility(IRegistry).forInterface(ITabellioSettings, False)
|
|
self.request.response.setHeader('Content-type', 'text/plain')
|
|
|
|
id = self.request.form.get('id')
|
|
if id:
|
|
try:
|
|
t = getattr(self.deputies_folder, id)
|
|
except AttributeError:
|
|
return 'XXX'
|
|
return t.Title()
|
|
|
|
s = []
|
|
q = normalizer.normalize(unicode(self.request.form.get('q'), 'utf-8')).lower()
|
|
for object in self.deputies_folder.objectValues():
|
|
if object.portal_type != 'themis.datatypes.deputy':
|
|
continue
|
|
if q in normalizer.normalize(object.Title()).lower():
|
|
s.append(object)
|
|
s.sort()
|
|
return '\n'.join(['%s|%s' % (x.Title(), x.id) for x in s])
|
|
|
|
class ListPolgroupsView(BrowserView):
|
|
def get_folder_at_path(self, path):
|
|
current = self.portal
|
|
for part in path.split('/'):
|
|
if not part:
|
|
continue
|
|
current = getattr(current, part)
|
|
return current
|
|
|
|
_polgroups_folder = None
|
|
def polgroups_folder(self):
|
|
if self._polgroups_folder:
|
|
return self._polgroups_folder
|
|
path = self.settings.polgroupsPath
|
|
self._polgroups_folder = self.get_folder_at_path(path)
|
|
return self._polgroups_folder
|
|
polgroups_folder = property(polgroups_folder)
|
|
|
|
def __call__(self):
|
|
self.portal = getToolByName(self.context, 'portal_url').getPortalObject()
|
|
self.settings = component.getUtility(IRegistry).forInterface(ITabellioSettings, False)
|
|
self.request.response.setHeader('Content-type', 'text/plain')
|
|
|
|
id = self.request.form.get('id')
|
|
if id:
|
|
try:
|
|
t = getattr(self.polgroups_folder, id)
|
|
except AttributeError:
|
|
return 'XXX'
|
|
return t.Title()
|
|
|
|
s = []
|
|
q = unicode(self.request.form.get('q'), 'utf-8').lower()
|
|
for object in self.polgroups_folder.objectValues():
|
|
if object.portal_type != 'themis.datatypes.polgroup':
|
|
continue
|
|
if q in object.id or q in object.Title().lower():
|
|
s.append(object)
|
|
return '\n'.join(['%s|%s' % (x.Title(), x.id) for x in s])
|
|
|
|
|
|
class ListTopicsView(BrowserView):
|
|
def __call__(self):
|
|
from plone.i18n.normalizer.fr import normalizer
|
|
topics = tabellio.config.utils.get_topics_dict()
|
|
self.request.response.setHeader('Content-type', 'text/plain')
|
|
|
|
id = self.request.form.get('id')
|
|
if id:
|
|
try:
|
|
return '%s' % topics.get(id, id)[0]
|
|
except KeyError:
|
|
return 'XXX'
|
|
|
|
query_terms = [normalizer.normalize(x).lower() for x in unicode(self.request.form.get('q'), 'utf-8').split()]
|
|
print 'query terms:', query_terms
|
|
|
|
sorted_topics = topics.items()
|
|
sorted_topics.sort(lambda x,y: cmp(x[1][1].lower(), y[1][1].lower()))
|
|
|
|
r = []
|
|
for key, value in sorted_topics:
|
|
for term in query_terms:
|
|
if not term in value[1].lower():
|
|
break
|
|
else:
|
|
r.append('%s|%s' % (value[0], key))
|
|
if len(r) > 30:
|
|
break
|
|
return '\n'.join(r)
|
|
|
|
|
|
class IAuthorsWidget(ITextWidget):
|
|
pass
|
|
|
|
class AuthorsWidget(text.TextWidget):
|
|
implements(IAuthorsWidget)
|
|
klass = u'authors'
|
|
|
|
def FieldAuthorsWidget(field, request):
|
|
return widget.FieldWidget(field, AuthorsWidget(request))
|
|
|
|
class IPolgroupsWidget(ITextWidget):
|
|
pass
|
|
|
|
class PolgroupsWidget(text.TextWidget):
|
|
implements(IPolgroupsWidget)
|
|
klass = u'polgroups'
|
|
|
|
def FieldPolgroupsWidget(field, request):
|
|
return widget.FieldWidget(field, PolgroupsWidget(request))
|
|
|
|
class ITopicsWidget(ITextWidget):
|
|
pass
|
|
|
|
class TopicsWidget(text.TextWidget):
|
|
implements(ITopicsWidget)
|
|
klass = u'topics'
|
|
|
|
def FieldTopicsWidget(field, request):
|
|
return widget.FieldWidget(field, TopicsWidget(request))
|
|
|
|
def FieldDroppedCheckboxWidget(field, request):
|
|
return widget.FieldWidget(field, CheckBoxWidget(request))
|
|
|
|
def FieldRadioboxesWidget(field, request):
|
|
return widget.FieldWidget(field, RadioWidget(request))
|
|
|
|
class IFolderWithDocuments(interface.Interface):
|
|
pass
|
|
|
|
class IFolderWithPfbDocuments(interface.Interface):
|
|
pass
|
|
|
|
def cmp_term(x, y):
|
|
from plone.i18n.normalizer.fr import normalizer
|
|
return cmp(normalizer.normalize(x.title), normalizer.normalize(y.title))
|
|
|
|
@grok.provider(IContextSourceBinder)
|
|
def possible_document_types(context):
|
|
catalog = getToolByName(context, 'portal_catalog')
|
|
possible_doctypes = catalog.uniqueValuesFor('doctype')
|
|
terms = []
|
|
for doctype in possible_doctypes:
|
|
if not doctype:
|
|
continue
|
|
doctype_id = doctype.encode('ascii', 'replace')
|
|
doctype_str = MAPPING.get(doctype, doctype)
|
|
terms.append(SimpleVocabulary.createTerm(doctype_id, doctype_id, doctype_str))
|
|
terms.sort(cmp_term)
|
|
return SimpleVocabulary(terms)
|
|
|
|
def get_docdos_type_id(context, type_id):
|
|
if type_id in MAPPING.keys():
|
|
return type_id
|
|
catalog = getToolByName(context, 'portal_catalog')
|
|
possible_doctypes = catalog.uniqueValuesFor('doctype')
|
|
possible_dostypes = catalog.uniqueValuesFor('dostype')
|
|
for iter_type_id in (possible_dostypes + possible_doctypes):
|
|
if iter_type_id is None:
|
|
continue
|
|
rep_id = iter_type_id.encode('ascii', 'replace')
|
|
if type_id in (iter_type_id, rep_id):
|
|
return iter_type_id
|
|
return None
|
|
|
|
|
|
@grok.provider(IContextSourceBinder)
|
|
def possible_dossier_types(context):
|
|
catalog = getToolByName(context, 'portal_catalog')
|
|
possible_dostypes = catalog.uniqueValuesFor('dostype')
|
|
terms = []
|
|
for dostype in possible_dostypes:
|
|
if not dostype:
|
|
continue
|
|
dostype_id = dostype.encode('ascii', 'replace')
|
|
dostype_str = MAPPING.get(dostype, dostype)
|
|
terms.append(SimpleVocabulary.createTerm(dostype_id, dostype_id, dostype_str))
|
|
terms.sort(cmp_term)
|
|
return SimpleVocabulary(terms)
|
|
|
|
@grok.provider(IContextSourceBinder)
|
|
def possible_question_types(context):
|
|
catalog = getToolByName(context, 'portal_catalog')
|
|
possible_questypes = catalog.uniqueValuesFor('questype')
|
|
terms = []
|
|
for questype in possible_questypes:
|
|
if not questype:
|
|
continue
|
|
questype_id = questype.encode('ascii', 'replace')
|
|
questype_str = MAPPING.get(questype, questype)
|
|
terms.append(SimpleVocabulary.createTerm(questype_id, questype_id, questype_str))
|
|
terms.sort(cmp_term)
|
|
return SimpleVocabulary(terms)
|
|
|
|
@grok.provider(IContextSourceBinder)
|
|
def possible_sessions(context):
|
|
terms = []
|
|
for term in tabellio.config.utils.get_legisl_and_sessions():
|
|
term_id = term.encode('ascii', 'replace')
|
|
terms.append(SimpleVocabulary.createTerm(term_id, term_id, term))
|
|
return SimpleVocabulary(terms)
|
|
|
|
@grok.provider(IContextSourceBinder)
|
|
def possible_polgroups(context):
|
|
terms = []
|
|
|
|
current = getToolByName(context, 'portal_url').getPortalObject()
|
|
settings = component.getUtility(IRegistry).forInterface(ITabellioSettings, False)
|
|
for part in settings.polgroupsPath.split('/'):
|
|
if not part:
|
|
continue
|
|
current = getattr(current, part)
|
|
|
|
for object in current.objectValues():
|
|
if object.portal_type != 'themis.datatypes.polgroup':
|
|
continue
|
|
polgroup_id = object.id
|
|
polgroup_str = object.Title()
|
|
terms.append(SimpleVocabulary.createTerm(polgroup_id, polgroup_id, polgroup_str))
|
|
return SimpleVocabulary(terms)
|
|
|
|
@grok.provider(IContextSourceBinder)
|
|
def possible_active_polgroups(context):
|
|
terms = []
|
|
|
|
current = getToolByName(context, 'portal_url').getPortalObject()
|
|
settings = component.getUtility(IRegistry).forInterface(ITabellioSettings, False)
|
|
for part in settings.polgroupsPath.split('/'):
|
|
if not part:
|
|
continue
|
|
current = getattr(current, part)
|
|
|
|
for object in current.objectValues():
|
|
if object.portal_type != 'themis.datatypes.polgroup':
|
|
continue
|
|
if not object.active:
|
|
continue
|
|
polgroup_id = object.id
|
|
polgroup_str = object.Title()
|
|
terms.append(SimpleVocabulary.createTerm(polgroup_id, polgroup_id, polgroup_str))
|
|
return SimpleVocabulary(terms)
|
|
|
|
|
|
|
|
@grok.provider(IContextSourceBinder)
|
|
def possible_topics(context):
|
|
catalog = getToolByName(context, 'portal_catalog')
|
|
topics = tabellio.config.utils.get_topics_dict()
|
|
terms = []
|
|
for key, value in sorted(topics.items()):
|
|
topic_id = key
|
|
topic_str = value[0]
|
|
terms.append(SimpleVocabulary.createTerm(topic_id, topic_id, topic_str))
|
|
return SimpleVocabulary(terms)
|
|
|
|
class IDocumentSearch(interface.Interface):
|
|
search_type_is_document = schema.TextLine(title=u'Search Type', default=u'1', required=False)
|
|
nodoc = schema.TextLine(title=_(u'Document Number'), required=False)
|
|
nosuite = schema.TextLine(title=_(u'Suite Number'), required=False)
|
|
doctype = schema.Choice(title=_(u'Type'), required=False,
|
|
source=possible_document_types)
|
|
ttitle = schema.TextLine(title=_(u'Title'), required=False)
|
|
text = schema.TextLine(title=_(u'Text'), required=False)
|
|
authors = schema.TextLine(title=_(u'Authors'), required=False)
|
|
polgroups = schema.TextLine(title=_(u'Political Groups'), required=False)
|
|
topics = schema.TextLine(title=_(u'Topics'), required=False)
|
|
session = schema.Choice(title=_(u'Legislature / Session'), required=False,
|
|
source=possible_sessions)
|
|
start = schema.Date(title=_(u'Start'), required=False)
|
|
end = schema.Date(title=_(u'End'), required=False)
|
|
|
|
sort_on = schema.Choice(title=_(u'Sort By'), required=True,
|
|
default=_(u'Session'),
|
|
values=[_(u'Session'), _(u'Type'), _(u'Number')])
|
|
|
|
|
|
class DocumentSearchForm(form.Form):
|
|
method = 'get'
|
|
prefix = 'document'
|
|
fields = field.Fields(IDocumentSearch)
|
|
fields['authors'].widgetFactory = FieldAuthorsWidget
|
|
fields['polgroups'].widgetFactory = FieldPolgroupsWidget
|
|
fields['topics'].widgetFactory = FieldTopicsWidget
|
|
ignoreContext = True
|
|
template = ViewPageTemplateFile('form_templates/view_form.pt')
|
|
|
|
def updateWidgets(self):
|
|
super(DocumentSearchForm, self).updateWidgets()
|
|
self.widgets['search_type_is_document'].mode = z3c.form.interfaces.HIDDEN_MODE
|
|
|
|
@button.buttonAndHandler(_(u'Search'))
|
|
def handleApply(self, action):
|
|
data, errors = self.extractData()
|
|
if not errors and False:
|
|
plone_utils = getToolByName(self.context.context, 'plone_utils')
|
|
plone_utils.addPortalMessage(_('Your search has been completed!'))
|
|
return self.request.response.redirect('./')
|
|
return
|
|
|
|
|
|
class IDossierSearch(interface.Interface):
|
|
search_type_is_dossier = schema.TextLine(title=u'Search Type', default=u'1', required=False)
|
|
|
|
nodos = schema.TextLine(title=_(u'Dossier Number'), required=False)
|
|
dostype = schema.Choice(title=_(u'Type'), required=False,
|
|
source=possible_dossier_types)
|
|
ttitle = schema.TextLine(title=_(u'Title'), required=False)
|
|
authors = schema.TextLine(title=_(u'Authors'), required=False)
|
|
polgroups = schema.TextLine(title=_(u'Political Groups'), required=False)
|
|
participants = schema.TextLine(title=_(u'Participants'), required=False)
|
|
topics = schema.TextLine(title=_(u'Topics'), required=False)
|
|
session = schema.Choice(title=_(u'Legislature / Session'), required=False,
|
|
source=possible_sessions)
|
|
adopted = schema.Bool(title=_(u'Limit to adopted'), required=False, default=False)
|
|
decreted = schema.Bool(title=_(u'Limit to decreted'), required=False, default=False)
|
|
start = schema.Date(title=_(u'Start'), required=False)
|
|
end = schema.Date(title=_(u'End'), required=False)
|
|
|
|
sort_on = schema.Choice(title=_(u'Sort By'), required=True,
|
|
default=_(u'Session'),
|
|
values=[_(u'Session'), _(u'Type'), _(u'Number')])
|
|
|
|
|
|
class DossierSearchForm(form.Form):
|
|
prefix = 'dossier'
|
|
method = 'get'
|
|
fields = field.Fields(IDossierSearch)
|
|
fields['authors'].widgetFactory = FieldAuthorsWidget
|
|
fields['participants'].widgetFactory = FieldAuthorsWidget
|
|
fields['polgroups'].widgetFactory = FieldPolgroupsWidget
|
|
fields['topics'].widgetFactory = FieldTopicsWidget
|
|
ignoreContext = True
|
|
template = ViewPageTemplateFile('form_templates/view_form.pt')
|
|
|
|
def updateWidgets(self):
|
|
super(DossierSearchForm, self).updateWidgets()
|
|
self.widgets['search_type_is_dossier'].mode = z3c.form.interfaces.HIDDEN_MODE
|
|
|
|
@button.buttonAndHandler(_(u'Search'))
|
|
def handleApply(self, action):
|
|
data, errors = self.extractData()
|
|
if not errors and False:
|
|
plone_utils = getToolByName(self.context.context, 'plone_utils')
|
|
plone_utils.addPortalMessage(_('Your search has been completed!'))
|
|
return self.request.response.redirect('./')
|
|
return
|
|
|
|
|
|
class IQuestionSearch(interface.Interface):
|
|
search_type_is_question = schema.TextLine(title=u'Search Type', default=u'1', required=False)
|
|
|
|
questype = schema.Choice(title=_(u'Type'), required=False,
|
|
source=possible_question_types)
|
|
ttitle = schema.TextLine(title=_(u'Title'), required=False)
|
|
authors = schema.TextLine(title=_(u'Authors'), required=False)
|
|
polgroups = schema.TextLine(title=_(u'Political Groups'), required=False)
|
|
topics = schema.TextLine(title=_(u'Topics'), required=False)
|
|
session = schema.Choice(title=_(u'Legislature / Session'), required=False,
|
|
source=possible_sessions)
|
|
start = schema.Date(title=_(u'Start'), required=False)
|
|
end = schema.Date(title=_(u'End'), required=False)
|
|
|
|
sort_on = schema.Choice(title=_(u'Sort By'), required=True,
|
|
default=_(u'Session'),
|
|
values=[_(u'Session'), _(u'Type')])
|
|
|
|
|
|
class QuestionSearchForm(form.Form):
|
|
prefix = 'question'
|
|
fields = field.Fields(IQuestionSearch)
|
|
fields['authors'].widgetFactory = FieldAuthorsWidget
|
|
fields['polgroups'].widgetFactory = FieldPolgroupsWidget
|
|
fields['topics'].widgetFactory = FieldTopicsWidget
|
|
ignoreContext = True
|
|
template = ViewPageTemplateFile('form_templates/view_form.pt')
|
|
|
|
def updateWidgets(self):
|
|
super(QuestionSearchForm, self).updateWidgets()
|
|
self.widgets['search_type_is_question'].mode = z3c.form.interfaces.HIDDEN_MODE
|
|
|
|
@button.buttonAndHandler(_(u'Search'))
|
|
def handleApply(self, action):
|
|
data, errors = self.extractData()
|
|
if not errors and False:
|
|
plone_utils = getToolByName(self.context.context, 'plone_utils')
|
|
plone_utils.addPortalMessage(_('Your search has been completed!'))
|
|
return self.request.response.redirect('./')
|
|
return
|
|
|
|
class QuestionPfbSearchForm(QuestionSearchForm):
|
|
fields = field.Fields(IQuestionSearch)
|
|
fields['sort_on'].widgetFactory = FieldRadioboxesWidget
|
|
|
|
|
|
class IDocumentPfbSearch(interface.Interface):
|
|
search_type_is_document = schema.TextLine(title=u'Search Type', default=u'1')
|
|
|
|
nodoc = schema.TextLine(title=_(u'Document Number'), required=False)
|
|
l_doctypes = schema.List(title=_(u'Types'), required=False,
|
|
value_type=schema.Choice(title=_(u'Type'), required=False,
|
|
source=possible_document_types))
|
|
ttitle = schema.TextLine(title=_(u'Title'), required=False,
|
|
description=_(u'Description for the title field'))
|
|
text = schema.TextLine(title=_(u'Text'), required=False)
|
|
authors = schema.TextLine(title=_(u'Authors'), required=False)
|
|
l_polgroups = schema.List(title=_(u'Political Groups'), required=False,
|
|
value_type=schema.Choice(title=_(u'Political Group'),
|
|
required=False, source=possible_polgroups))
|
|
l_topics = schema.List(title=_(u'Topics'), required=False,
|
|
value_type=schema.Choice(required=False,
|
|
source=possible_topics));
|
|
session = schema.Choice(title=_(u'Legislature / Session'), required=False,
|
|
source=possible_sessions)
|
|
start = schema.Date(title=_(u'Start'), required=False)
|
|
end = schema.Date(title=_(u'End'), required=False)
|
|
|
|
sort_on = schema.Choice(title=_(u'Sort By'), required=True,
|
|
default=_(u'Session'),
|
|
values=[_(u'Session'), _(u'Type'), _(u'Number')])
|
|
|
|
|
|
class DocumentPfbSearchForm(form.Form):
|
|
method = 'get'
|
|
prefix = 'document'
|
|
fields = field.Fields(IDocumentPfbSearch)
|
|
fields['authors'].widgetFactory = FieldAuthorsWidget
|
|
fields['l_doctypes'].widgetFactory = FieldDroppedCheckboxWidget
|
|
fields['l_polgroups'].widgetFactory = FieldDroppedCheckboxWidget
|
|
fields['l_topics'].widgetFactory = FieldDroppedCheckboxWidget
|
|
fields['sort_on'].widgetFactory = FieldRadioboxesWidget
|
|
ignoreContext = True
|
|
template = ViewPageTemplateFile('form_templates/view_form.pt')
|
|
|
|
def updateWidgets(self):
|
|
super(DocumentPfbSearchForm, self).updateWidgets()
|
|
self.widgets['search_type_is_document'].mode = z3c.form.interfaces.HIDDEN_MODE
|
|
|
|
@button.buttonAndHandler(_(u'Submit'))
|
|
def handleApply(self, action):
|
|
data, errors = self.extractData()
|
|
if not errors and False:
|
|
plone_utils = getToolByName(self.context.context, 'plone_utils')
|
|
plone_utils.addPortalMessage(_('Your search has been completed!'))
|
|
return self.request.response.redirect('./')
|
|
return
|
|
|
|
|
|
class IAdoptedDocumentPfbSearch(interface.Interface):
|
|
search_type_is_adopteddocument = schema.TextLine(title=u'Search Type', default=u'1')
|
|
|
|
nodoc = schema.TextLine(title=_(u'Document Number'), required=False)
|
|
l_doctypes = schema.List(title=_(u'Types'), required=False,
|
|
value_type=schema.Choice(title=_(u'Type'), required=False,
|
|
values=[_(u'Projets'), _(u'Propositions')]))
|
|
ttitle = schema.TextLine(title=_(u'Title'), required=False)
|
|
text = schema.TextLine(title=_(u'Text'), required=False)
|
|
authors = schema.TextLine(title=_(u'Authors'), required=False)
|
|
l_polgroups = schema.List(title=_(u'Political Groups'), required=False,
|
|
value_type=schema.Choice(title=_(u'Political Group'),
|
|
required=False, source=possible_polgroups))
|
|
l_topics = schema.List(title=_(u'Topics'), required=False,
|
|
value_type=schema.Choice(required=False,
|
|
source=possible_topics));
|
|
session = schema.Choice(title=_(u'Legislature / Session'), required=False,
|
|
source=possible_sessions)
|
|
start = schema.Date(title=_(u'Start'), required=False)
|
|
end = schema.Date(title=_(u'End'), required=False)
|
|
adopted = schema.Bool(title=_(u'Limit to adopted'), required=False, default=True)
|
|
|
|
sort_on = schema.Choice(title=_(u'Sort By'), required=True,
|
|
default=_(u'Session'),
|
|
values=[_(u'Session'), _(u'Type'), _(u'Number')])
|
|
|
|
|
|
class AdoptedDocumentPfbSearchForm(form.Form):
|
|
prefix = 'adopteddocument'
|
|
fields = field.Fields(IAdoptedDocumentPfbSearch)
|
|
fields['authors'].widgetFactory = FieldAuthorsWidget
|
|
fields['l_doctypes'].widgetFactory = FieldDroppedCheckboxWidget
|
|
fields['l_polgroups'].widgetFactory = FieldDroppedCheckboxWidget
|
|
fields['l_topics'].widgetFactory = FieldDroppedCheckboxWidget
|
|
fields['sort_on'].widgetFactory = FieldRadioboxesWidget
|
|
ignoreContext = True
|
|
template = ViewPageTemplateFile('form_templates/view_form.pt')
|
|
|
|
def updateWidgets(self):
|
|
super(AdoptedDocumentPfbSearchForm, self).updateWidgets()
|
|
self.widgets['adopted'].mode = z3c.form.interfaces.HIDDEN_MODE
|
|
self.widgets['search_type_is_adopteddocument'].mode = z3c.form.interfaces.HIDDEN_MODE
|
|
|
|
@button.buttonAndHandler(_(u'Submit'))
|
|
def handleApply(self, action):
|
|
pass
|
|
|
|
|
|
|
|
class IDeputySearch(interface.Interface):
|
|
search_type_is_deputy = schema.TextLine(title=u'Search Type', default=u'1', required=False)
|
|
|
|
name = schema.TextLine(title=_(u'Name'), required=False)
|
|
polgroup = schema.Choice(title=_(u'Political Group'),
|
|
required=False, source=possible_active_polgroups)
|
|
|
|
|
|
class DeputySearchForm(form.Form):
|
|
prefix = 'deputy'
|
|
fields = field.Fields(IDeputySearch)
|
|
ignoreContext = True
|
|
template = ViewPageTemplateFile('form_templates/view_form.pt')
|
|
|
|
def updateWidgets(self):
|
|
super(DeputySearchForm, self).updateWidgets()
|
|
self.widgets['search_type_is_deputy'].mode = z3c.form.interfaces.HIDDEN_MODE
|
|
|
|
@button.buttonAndHandler(_(u'Submit'))
|
|
def handleApply(self, action):
|
|
pass
|
|
|
|
|
|
class IEventSearch(interface.Interface):
|
|
search_type_is_event = schema.TextLine(title=u'Search Type', default=u'1', required=False)
|
|
|
|
start = schema.Date(title=_(u'Start'), required=False)
|
|
end = schema.Date(title=_(u'End'), required=False)
|
|
|
|
|
|
class EventSearchForm(form.Form):
|
|
prefix = 'event'
|
|
fields = field.Fields(IEventSearch)
|
|
ignoreContext = True
|
|
template = ViewPageTemplateFile('form_templates/view_form.pt')
|
|
|
|
def updateWidgets(self):
|
|
super(EventSearchForm, self).updateWidgets()
|
|
self.widgets['search_type_is_event'].mode = z3c.form.interfaces.HIDDEN_MODE
|
|
|
|
@button.buttonAndHandler(_(u'Submit'))
|
|
def handleApply(self, action):
|
|
pass
|
|
|
|
|
|
class IGlobalSearchForm(interface.Interface):
|
|
search_type_is_document = schema.TextLine(title=u'Search Type', required=False)
|
|
search_type_is_adopteddocument = schema.TextLine(title=u'Search Type', required=False)
|
|
search_type_is_dossier = schema.TextLine(title=u'Search Type', required=False)
|
|
search_type_is_question = schema.TextLine(title=u'Search Type', required=False)
|
|
|
|
nodoc = schema.TextLine(title=_(u'Document Number'), required=False)
|
|
nosuite = schema.TextLine(title=_(u'Suite Number'), required=False)
|
|
doctype = schema.Choice(title=_(u'Type'), required=False,
|
|
source=possible_document_types)
|
|
|
|
nodos = schema.TextLine(title=_(u'Dossier Number'), required=False)
|
|
dostype = schema.Choice(title=_(u'Type'), required=False,
|
|
source=possible_dossier_types)
|
|
|
|
questype = schema.Choice(title=_(u'Type'), required=False,
|
|
source=possible_question_types)
|
|
|
|
ttitle = schema.TextLine(title=_(u'Title'), required=False)
|
|
text = schema.TextLine(title=_(u'Text'), required=False)
|
|
authors = schema.TextLine(title=_(u'Authors'), required=False)
|
|
participants = schema.TextLine(title=_(u'Participants'), required=False)
|
|
polgroups = schema.TextLine(title=_(u'Political Groups'), required=False)
|
|
topics = schema.TextLine(title=_(u'Topics'), required=False)
|
|
session = schema.Choice(title=_(u'Legislature / Session'), required=False,
|
|
source=possible_sessions)
|
|
start = schema.Date(title=_(u'Start'), required=False)
|
|
end = schema.Date(title=_(u'End'), required=False)
|
|
adopted = schema.Bool(title=_(u'Limit to adopted'), required=False, default=False)
|
|
decreted = schema.Bool(title=_(u'Limit to decreted'), required=False, default=False)
|
|
|
|
l_doctypes = schema.List(title=_(u'Types'), required=False,
|
|
value_type=schema.Choice(title=_(u'Type'), required=False,
|
|
source=possible_document_types))
|
|
l_polgroups = schema.List(title=_(u'Political Groups'), required=False,
|
|
value_type=schema.Choice(title=_(u'Political Group'),
|
|
required=False, source=possible_polgroups))
|
|
l_topics = schema.List(title=_(u'Topics'), required=False,
|
|
value_type=schema.Choice(required=False,
|
|
source=possible_topics));
|
|
|
|
sort_on = schema.Choice(title=_(u'Sort By'), required=False,
|
|
default=_(u'Type'),
|
|
values=[_(u'Type'), _(u'Number'), _(u'Session')])
|
|
|
|
|
|
class GlobalSearchForm(form.Form):
|
|
fields = field.Fields(IGlobalSearchForm)
|
|
ignoreContext = True
|
|
|
|
class SearchView(BrowserView):
|
|
batch_macros = ViewPageTemplateFile('batch_macros.pt')
|
|
js_macros = ViewPageTemplateFile('js_macros.pt')
|
|
|
|
def portal_url(self):
|
|
return getToolByName(self.context, 'portal_url').getPortalPath()
|
|
|
|
def db_connection(self):
|
|
portal = getToolByName(self.context, 'portal_url').getPortalObject()
|
|
return portal.db._wrapper.connection
|
|
db_connection = property(db_connection)
|
|
|
|
def _get_ids_cache_key(method, self, text):
|
|
return (text, )
|
|
|
|
@ram.cache(_get_ids_cache_key)
|
|
def get_ids_from_postgres(self, text):
|
|
try:
|
|
cursor = self.db_connection.cursor()
|
|
except AttributeError:
|
|
return []
|
|
# looks like there's no way to quote things properly for to_tsquery,
|
|
from plone.i18n.normalizer.fr import normalizer
|
|
text = re.sub(r'[^\w\s]', ' ', normalizer.normalize(text))
|
|
cursor.execute("""SELECT t_document.id
|
|
FROM t_document JOIN t_file
|
|
ON (t_document.text1id = t_file.fileid OR
|
|
t_document.textdefid = t_file.fileid)
|
|
WHERE object_fts @@ to_tsquery('default_french', '''%s''')""" % text)
|
|
ids = [x[0] for x in cursor.fetchall()]
|
|
cursor.close()
|
|
return ids
|
|
|
|
def get_batchlinkparams(self):
|
|
d = dict()
|
|
for key in self.request.form:
|
|
d[key] = self.request.form[key]
|
|
if type(d[key]) is str:
|
|
d[key] = unicode(d[key], 'utf-8').encode('utf-8')
|
|
elif type(d[key]) is unicode:
|
|
d[key] = d[key].encode('utf-8')
|
|
return d
|
|
|
|
def search_results(self, search_type):
|
|
print 'search type:', search_type
|
|
|
|
if self.request.form.get('document.widgets.search_type_is_document'):
|
|
GlobalSearchForm.prefix = 'document'
|
|
elif self.request.form.get('dossier.widgets.search_type_is_dossier'):
|
|
GlobalSearchForm.prefix = 'dossier'
|
|
elif self.request.form.get('question.widgets.search_type_is_question'):
|
|
GlobalSearchForm.prefix = 'question'
|
|
elif self.request.form.get('adopteddocument.widgets.search_type_is_adopteddocument'):
|
|
GlobalSearchForm.prefix = 'adopteddocument'
|
|
|
|
f = GlobalSearchForm(self.context, self.request)
|
|
f.update()
|
|
|
|
data, errors = f.extractData()
|
|
kw = {}
|
|
|
|
if not data.get('search_type_is_%s' % search_type):
|
|
return None
|
|
print 'data:', data
|
|
|
|
if data.get('ttitle'):
|
|
kw['Title'] = data.get('ttitle')
|
|
|
|
if data.get('nodoc'):
|
|
kw['no'] = data.get('nodoc')
|
|
|
|
if data.get('nosuite'):
|
|
kw['nodoc'] = data.get('nosuite')
|
|
|
|
if data.get('nodos'):
|
|
kw['no'] = data.get('nodos')
|
|
|
|
if data.get('doctype'):
|
|
kw['doctype'] = get_docdos_type_id(self.context, data.get('doctype'))
|
|
if data.get('dostype'):
|
|
kw['dostype'] = get_docdos_type_id(self.context, data.get('dostype'))
|
|
if data.get('l_doctypes'):
|
|
kw['doctype'] = [get_docdos_type_id(self.context, x) for x in data.get('l_doctypes')]
|
|
|
|
if data.get('start') and data.get('end'):
|
|
kw['dateDoc'] = {'query': [data.get('start'), data.get('end')], 'range': 'minmax'}
|
|
elif data.get('start'):
|
|
kw['dateDoc'] = {'query': data.get('start'), 'range': 'min'}
|
|
elif data.get('end'):
|
|
kw['dateDoc'] = {'query': data.get('end'), 'range': 'max'}
|
|
|
|
if data.get('session'):
|
|
kw['session'] = tabellio.config.utils.get_list_of_sessions(data.get('session'))
|
|
|
|
if data.get('authors'):
|
|
kw['authorsDoc'] = {'query': data.get('authors').strip().split(),
|
|
'operator': 'and'}
|
|
|
|
if data.get('participants'):
|
|
kw['interveningPersonsDoc'] = {
|
|
'query': data.get('participants').strip().split(),
|
|
'operator': 'and'}
|
|
|
|
if data.get('polgroups'):
|
|
kw['polgroupsDoc'] = {'query': data.get('polgroups').strip().split(),
|
|
'operator': 'and'}
|
|
if data.get('l_polgroups'):
|
|
kw['polgroupsDoc'] = {'query': [possible_polgroups(self.context).getTermByToken(x).title for x in data.get('l_polgroups')],
|
|
'operator': 'and'}
|
|
|
|
if data.get('topics'):
|
|
kw['topics'] = {'query': data.get('topics').strip().split(),
|
|
'operator': 'and'}
|
|
if data.get('l_topics'):
|
|
kw['topics'] = {'query': [possible_topics(self.context).getTermByToken(x).title for x in data.get('l_topics')],
|
|
'operator': 'and'}
|
|
|
|
if data.get('adopted'):
|
|
kw['adopted'] = data.get('adopted')
|
|
|
|
if data.get('decreted'):
|
|
kw['decreted'] = data.get('decreted')
|
|
|
|
if not kw and not data.get('text'):
|
|
return []
|
|
|
|
if data.get('text'):
|
|
# plaintext search, get document ids from postgresql
|
|
kw['id'] = self.get_ids_from_postgres(data.get('text'))
|
|
|
|
if data.get('search_type_is_document'):
|
|
kw['portal_type'] = 'tabellio.documents.document'
|
|
elif data.get('search_type_is_adopteddocument'):
|
|
kw['portal_type'] = 'tabellio.documents.document'
|
|
elif data.get('search_type_is_dossier'):
|
|
kw['portal_type'] = 'tabellio.documents.dossier'
|
|
elif data.get('search_type_is_question'):
|
|
kw['portal_type'] = 'tabellio.documents.question'
|
|
|
|
from plone.i18n.normalizer.fr import normalizer
|
|
def cmp_doctype(x, y):
|
|
if not (x.doctype is None or y.doctype is None or
|
|
x.doctype is Missing.Value or y.doctype is Missing.Value):
|
|
type_x = normalizer.normalize(MAPPING.get(x.doctype, x.doctype))
|
|
type_y = normalizer.normalize(MAPPING.get(y.doctype, y.doctype))
|
|
t = cmp(type_x, type_y)
|
|
else:
|
|
t = -cmp(x.doctype, y.doctype)
|
|
if t == 0:
|
|
t = -cmp(x.session, y.session)
|
|
if t == 0:
|
|
t = -cmp(x.no, y.no)
|
|
if t == 0:
|
|
t = cmp(x.nodoc, y.nodoc)
|
|
return t
|
|
|
|
def get_no_as_int(i):
|
|
if i:
|
|
try:
|
|
return int(i.split('-')[0])
|
|
except ValueError:
|
|
return 99999
|
|
return 0
|
|
|
|
ordered_sessions = tabellio.config.utils.get_ordered_sessions()
|
|
def cmp_session_name(x, y):
|
|
if x is y or x == y:
|
|
return 0
|
|
if x not in ordered_sessions:
|
|
return -1
|
|
if y not in ordered_sessions:
|
|
return +1
|
|
return cmp(ordered_sessions.index(x), ordered_sessions.index(y))
|
|
|
|
def cmp_dostype(x, y):
|
|
if not (x.dostype is None or y.dostype is None or
|
|
x.dostype is Missing.Value or y.dostype is Missing.Value):
|
|
type_x = normalizer.normalize(MAPPING.get(x.dostype, x.dostype))
|
|
type_y = normalizer.normalize(MAPPING.get(y.dostype, y.dostype))
|
|
else:
|
|
t = -cmp(x.dostype, y.dostype)
|
|
t = cmp(type_x, type_y)
|
|
if t == 0:
|
|
t = -cmp_session_name(x.session, y.session)
|
|
if t == 0:
|
|
t = -cmp(x.no, y.no)
|
|
return t
|
|
|
|
def cmp_questype(x, y):
|
|
if not (x.questype is None or y.questype is None or
|
|
x.questype is Missing.Value or y.questype is Missing.Value):
|
|
type_x = normalizer.normalize(MAPPING.get(x.questype, x.questype))
|
|
type_y = normalizer.normalize(MAPPING.get(y.questype, y.questype))
|
|
else:
|
|
t = -cmp(x.questype, y.questype)
|
|
t = cmp(type_x, type_y)
|
|
if t == 0:
|
|
t = -cmp_session_name(x.session, y.session)
|
|
if t == 0:
|
|
t = -cmp(x.dateDoc, y.dateDoc)
|
|
return t
|
|
|
|
def cmp_number(x, y):
|
|
t = -cmp(get_no_as_int(x.no), get_no_as_int(y.no))
|
|
if t == 0:
|
|
t = -cmp_session_name(x.session, y.session)
|
|
if t == 0:
|
|
t = cmp(x.nodoc, y.nodoc)
|
|
return t
|
|
|
|
def cmp_session(x, y):
|
|
t = -cmp_session_name(x.session, y.session)
|
|
if t == 0:
|
|
t = -cmp(get_no_as_int(x.no), get_no_as_int(y.no))
|
|
if t == 0 and hasattr(x, 'nodoc'):
|
|
t = cmp(x.nodoc, y.nodoc)
|
|
return t
|
|
|
|
cmp_function = None
|
|
if data.get('sort_on') == 'Type':
|
|
if data.get('search_type_is_document'):
|
|
cmp_function = cmp_doctype
|
|
elif data.get('search_type_is_adopteddocument'):
|
|
cmp_function = cmp_doctype
|
|
elif data.get('search_type_is_dossier'):
|
|
cmp_function = cmp_dostype
|
|
elif data.get('search_type_is_question'):
|
|
cmp_function = cmp_questype
|
|
elif data.get('sort_on') == 'Number':
|
|
cmp_function = cmp_number
|
|
elif data.get('sort_on') == 'Session':
|
|
cmp_function = cmp_session
|
|
|
|
catalog = getToolByName(self.context, 'portal_catalog')
|
|
print 'kw:', kw
|
|
return sorted(catalog(**kw), cmp_function)
|
|
|
|
def deputy_search_form(self):
|
|
f = DeputySearchForm(self.context, self.request)
|
|
f.update()
|
|
return f.render()
|
|
|
|
def document_pfb_search_form(self):
|
|
f = DocumentPfbSearchForm(self.context, self.request)
|
|
f.update()
|
|
return f.render()
|
|
|
|
def question_pfb_search_form(self):
|
|
f = QuestionPfbSearchForm(self.context, self.request)
|
|
f.update()
|
|
return f.render()
|
|
|
|
def document_search_form(self):
|
|
f = DocumentSearchForm(self.context, self.request)
|
|
f.update()
|
|
return f.render()
|
|
|
|
def document_search_results(self):
|
|
return self.search_results(search_type='document')
|
|
|
|
def adopted_document_pfb_search_form(self):
|
|
f = AdoptedDocumentPfbSearchForm(self.context, self.request)
|
|
f.update()
|
|
return f.render()
|
|
|
|
def adopted_document_search_results(self):
|
|
return self.search_results(search_type='adopteddocument')
|
|
|
|
def dossier_search_form(self):
|
|
f = DossierSearchForm(self.context, self.request)
|
|
f.update()
|
|
return f.render()
|
|
|
|
def dossier_search_results(self):
|
|
return self.search_results(search_type='dossier')
|
|
|
|
def question_search_form(self):
|
|
f = QuestionSearchForm(self.context, self.request)
|
|
f.update()
|
|
return f.render()
|
|
|
|
def question_search_results(self):
|
|
return self.search_results(search_type='question')
|
|
|
|
def event_search_form(self):
|
|
f = EventSearchForm(self.context, self.request)
|
|
f.update()
|
|
return f.render()
|
|
|
|
def event_search_results(self):
|
|
f = EventSearchForm(self.context, self.request)
|
|
f.update()
|
|
|
|
data, errors = f.extractData()
|
|
kw = {}
|
|
|
|
if not data.get('search_type_is_event'):
|
|
return None
|
|
|
|
if data.get('start') and data.get('end'):
|
|
kw['start'] = {'query': [data.get('start'), data.get('end')], 'range': 'minmax'}
|
|
elif data.get('start'):
|
|
kw['start'] = {'query': data.get('start'), 'range': 'min'}
|
|
elif data.get('end'):
|
|
kw['start'] = {'query': data.get('end'), 'range': 'max'}
|
|
|
|
kw['sort_on'] = 'start'
|
|
kw['sort_order'] = 'descending'
|
|
|
|
kw['portal_type'] = ('tabellio.agenda.event',
|
|
'tabellio.agenda.comevent',
|
|
'tabellio.agenda.parlevent')
|
|
|
|
catalog = getToolByName(self.context, 'portal_catalog')
|
|
return catalog(**kw)
|
|
|
|
def docform_url(self):
|
|
catalog = getToolByName(self.context, 'portal_catalog')
|
|
try:
|
|
return catalog(
|
|
portal_type='Folder',
|
|
object_provides=('tabellio.searchform.form.IFolderWithPfbDocuments',
|
|
'tabellio.searchform.form.IFolderWithDocuments'),
|
|
limit=1)[0].getObject().absolute_url()
|
|
except IndexError:
|
|
return '#'
|
|
|
|
def deputiesform_url(self):
|
|
catalog = getToolByName(self.context, 'portal_catalog')
|
|
try:
|
|
return catalog(
|
|
portal_type='Folder',
|
|
object_provides=('tabellio.webviews.deputy.IDeputiesAndOthersFolderView',
|
|
'tabellio.webviews.deputy.IPfbDeputiesFolderView',
|
|
'tabellio.webviews.deputy.IFolderView'),
|
|
limit=1)[0].getObject().absolute_url()
|
|
except IndexError:
|
|
return '#'
|
|
|
|
def eventform_url(self):
|
|
return self.portal_url() + '/eventsearch'
|
|
|
|
def decrets_years(self):
|
|
now = time.localtime()
|
|
return range(1973, now[0]+1)
|
|
|
|
def decrets_year(self):
|
|
now = time.localtime()
|
|
year = int(self.request.form.get('year') or now[0])
|
|
return year
|
|
|
|
def decrets(self):
|
|
now = time.localtime()
|
|
year = int(self.request.form.get('year') or now[0])
|
|
|
|
start = datetime.datetime(year, 1, 1)
|
|
end = datetime.datetime(year+1, 1, 1)
|
|
|
|
catalog = getToolByName(self.context, 'portal_catalog')
|
|
rs = catalog(portal_type='tabellio.documents.document',
|
|
doctype='DECCCF',
|
|
dateDoc={'query': (start, end), 'range': 'min:max'},
|
|
sort_on='dateDoc')
|
|
return rs
|
|
|
|
|
|
class Reflex(BrowserView):
|
|
def __call__(self):
|
|
kw = {}
|
|
if self.request.form.get('no'):
|
|
kw['no'] = self.request.form.get('no')
|
|
if self.request.form.get('sess'):
|
|
kw['session'] = self.request.form.get('sess')
|
|
if self.request.form.get('nodoc'):
|
|
kw['nodoc'] = self.request.form.get('nodoc')
|
|
|
|
if self.request.form.get('type') == 'document':
|
|
kw['portal_type'] = 'tabellio.documents.document'
|
|
elif self.request.form.get('type') == 'dossier':
|
|
kw['portal_type'] = 'tabellio.documents.dossier'
|
|
|
|
catalog = getToolByName(self.context, 'portal_catalog')
|
|
rs = catalog(**kw)
|
|
if not rs:
|
|
return self.request.response.redirect('.')
|
|
return self.request.response.redirect(rs[0].getURL())
|
|
|