示例#1
0
    def setUp(self):
        super(TestFilterList, self).setUp()

        self.filter_all = Filter('filter_all', 'All')
        self.filter_active = CatalogQueryFilter(
            'filter_active', 'Active', default=True,
            query_extension={'review_state': ['state-open']})
        self.filter_closed = CatalogQueryFilter(
            'filter_closed', 'Closed',
            query_extension={'review_state': ['state-closed']})

        self.filter_list = FilterList(
            self.filter_all, self.filter_active, self.filter_closed)
    def setUp(self):
        super(TestFilterList, self).setUp()

        self.filter_all = Filter('filter_all', 'All')
        self.filter_active = CatalogQueryFilter(
            'filter_active',
            'Active',
            default=True,
            query_extension={'review_state': ['state-open']})
        self.filter_closed = CatalogQueryFilter(
            'filter_closed',
            'Closed',
            query_extension={'review_state': ['state-closed']})

        self.filter_list = FilterList(self.filter_all, self.filter_active,
                                      self.filter_closed)
示例#3
0
class Dispositions(BaseCatalogListingTab):
    grok.name('tabbedview_view-dispositions')

    types = ['opengever.disposition.disposition']
    enabled_actions = []
    major_actions = []

    filterlist_name = 'disposition_state_filter'
    filterlist_available = True
    filterlist = FilterList(
        Filter('filter_all', _('all')),
        CatalogQueryFilter('filter_active',
                           _('active'),
                           default=True,
                           query_extension={'review_state': ACTIVE_STATES}))

    columns = (
        {
            'column': '',
            'column_title': '',
            'transform': path_checkbox,
            'sortable': False,
            'width': 30
        },
        {
            'column':
            'sequence_number',
            'column_title':
            _(u'document_sequence_number', default=u'Sequence Number'),
            'sort_index':
            'sequence_number'
        },
        {
            'column': 'Title',
            'column_title': _(u'label_title', default=u'Title'),
            'sort_index': 'sortable_title',
            'transform': linked
        },
        {
            'column': 'review_state',
            'column_title': _(u'label_review_state', default=u'Review state'),
            'transform': workflow_state
        },
    )
示例#4
0
class Dossiers(BaseCatalogListingTab):
    """List all dossiers recursively."""

    template = ViewPageTemplateFile("generic_with_filters.pt")
    subject_filter_available = True

    object_provides = 'opengever.dossier.behaviors.dossier.IDossierMarker'

    columns = (
        {
            'column': '',
            'column_title': '',
            'transform': helper.path_checkbox,
            'sortable': False,
            'groupable': False,
            'width': 30
        },
        {
            'column': 'reference',
            'column_title': _(u'label_reference', default=u'Reference Number')
        },
        {
            'column': 'Title',
            'column_title': _(u'label_title', default=u'Title'),
            'sort_index': 'sortable_title',
            'transform': linked
        },
        {
            'column': 'review_state',
            'column_title': _(u'label_review_state', default=u'Review state'),
            'transform': workflow_state
        },
        {
            'column': 'responsible',
            'column_title': _(u'label_dossier_responsible',
                              default=u"Responsible"),
            'transform': readable_ogds_author
        },
        {
            'column': 'start',
            'column_title': _(u'label_start', default=u'Start'),
            'transform': readable_date
        },
        {
            'column': 'end',
            'column_title': _(u'label_end', default=u'End'),
            'transform': readable_date
        },
        {
            'column': 'Subject',
            'column_title': _(u'label_keywords', default=u'Keywords'),
            'transform': linked_subjects,
            'sortable': False
        },
    )

    search_options = {'is_subdossier': False}

    enabled_actions = [
        'change_state',
        'pdf_dossierlisting',
        'export_dossiers',
        'move_items',
        'copy_items',
        'create_disposition',
        'ech0147_export',
    ]

    major_actions = [
        'change_state',
    ]

    all_filter = Filter('filter_all', _('label_tabbedview_filter_all'))
    active_filter = CatalogQueryFilter(
        'filter_active',
        _('Active'),
        default=True,
        query_extension={'review_state': DOSSIER_STATES_OPEN})
    expired_filter = CatalogQueryFilter('filter_retention_expired',
                                        _('expired'),
                                        query_extension={
                                            'review_state':
                                            DOSSIER_STATES_CLOSED,
                                            'retention_expiration': {
                                                'query': date.today(),
                                                'range': 'max'
                                            }
                                        })
    overdue_filter = CatalogQueryFilter(
        'filter_overdue',
        _('overdue'),
        query_extension={
            'review_state': DOSSIER_STATES_OPEN,
            'end': {
                'query': date.today() - timedelta(days=1),
                'range': 'max'
            }
        })

    filterlist_name = 'dossier_state_filter'
    filterlist_available = True

    @property
    def filterlist(self):
        filters = [self.all_filter, self.active_filter]

        if api.user.has_permission('opengever.disposition: Add disposition'):
            filters.append(self.expired_filter)

        filters.append(self.overdue_filter)

        return FilterList(*filters)
class TestFilterList(TestCase):
    def setUp(self):
        super(TestFilterList, self).setUp()

        self.filter_all = Filter('filter_all', 'All')
        self.filter_active = CatalogQueryFilter(
            'filter_active',
            'Active',
            default=True,
            query_extension={'review_state': ['state-open']})
        self.filter_closed = CatalogQueryFilter(
            'filter_closed',
            'Closed',
            query_extension={'review_state': ['state-closed']})

        self.filter_list = FilterList(self.filter_all, self.filter_active,
                                      self.filter_closed)

    def test_get_by_filter_id(self):
        self.assertEquals(self.filter_all, self.filter_list['filter_all'])

        self.assertEquals(self.filter_active,
                          self.filter_list['filter_active'])

    def test_default_filter(self):
        self.assertEquals(self.filter_active, self.filter_list.default_filter)

    def test_only_one_default_filter_possible(self):
        with self.assertRaises(ValueError) as cm:
            FilterList(Filter('all', 'All', default=True),
                       Filter('active', 'Active', default=True))

        self.assertEquals('Only one filter marked as default possible.',
                          str(cm.exception))

    def test_filters_are_ordered(self):
        self.assertEquals(
            [self.filter_all, self.filter_active, self.filter_closed],
            self.filter_list.filters())

    def test_is_active_when_id_matchs(self):
        selected_filter_id = 'filter_all'

        self.assertTrue(self.filter_all.is_active(selected_filter_id))
        self.assertFalse(self.filter_active.is_active(selected_filter_id))
        self.assertFalse(self.filter_closed.is_active(selected_filter_id))

    def test_is_active_when_its_the_default_and_currently_no_filter_is_selected(
            self):
        selected_filter_id = None

        self.assertFalse(self.filter_all.is_active(selected_filter_id))
        self.assertTrue(self.filter_active.is_active(selected_filter_id))
        self.assertFalse(self.filter_closed.is_active(selected_filter_id))

    def test_update_query_by_selected_filter(self):
        selected_filter_id = 'filter_closed'

        self.assertEquals({'review_state': ['state-closed']},
                          self.filter_list.update_query({},
                                                        selected_filter_id))

    def test_update_query_by_default_filter_when_no_filter_is_selected(self):
        selected_filter_id = None

        self.assertEquals({'review_state': ['state-open']},
                          self.filter_list.update_query({},
                                                        selected_filter_id))
示例#6
0
class TestFilterList(TestCase):

    def setUp(self):
        super(TestFilterList, self).setUp()

        self.filter_all = Filter('filter_all', 'All')
        self.filter_active = CatalogQueryFilter(
            'filter_active', 'Active', default=True,
            query_extension={'review_state': ['state-open']})
        self.filter_closed = CatalogQueryFilter(
            'filter_closed', 'Closed',
            query_extension={'review_state': ['state-closed']})

        self.filter_list = FilterList(
            self.filter_all, self.filter_active, self.filter_closed)

    def test_get_by_filter_id(self):
        self.assertEquals(
            self.filter_all, self.filter_list['filter_all'])

        self.assertEquals(
            self.filter_active, self.filter_list['filter_active'])

    def test_default_filter(self):
        self.assertEquals(self.filter_active, self.filter_list.default_filter)

    def test_only_one_default_filter_possible(self):
        with self.assertRaises(ValueError) as cm:
            FilterList(Filter('all', 'All', default=True),
                       Filter('active', 'Active', default=True))

        self.assertEquals(
            'Only one filter marked as default possible.',
            str(cm.exception))

    def test_filters_are_ordered(self):
        self.assertEquals(
            [self.filter_all, self.filter_active, self.filter_closed],
            self.filter_list.filters())

    def test_is_active_when_id_matchs(self):
        selected_filter_id = 'filter_all'

        self.assertTrue(self.filter_all.is_active(selected_filter_id))
        self.assertFalse(self.filter_active.is_active(selected_filter_id))
        self.assertFalse(self.filter_closed.is_active(selected_filter_id))

    def test_is_active_when_its_the_default_and_currently_no_filter_is_selected(self):
        selected_filter_id = None

        self.assertFalse(self.filter_all.is_active(selected_filter_id))
        self.assertTrue(self.filter_active.is_active(selected_filter_id))
        self.assertFalse(self.filter_closed.is_active(selected_filter_id))

    def test_update_query_by_selected_filter(self):
        selected_filter_id = 'filter_closed'

        self.assertEquals(
            {'review_state': ['state-closed']},
            self.filter_list.update_query({}, selected_filter_id))

    def test_update_query_by_default_filter_when_no_filter_is_selected(self):
        selected_filter_id = None

        self.assertEquals(
            {'review_state': ['state-open']},
            self.filter_list.update_query({}, selected_filter_id))