def __init__(self, context, request):
     self._assignable_roles = []
     self.principal = utils.get_principal()
     self.context_roles = common.get_context_roles(
         context, self.principal)
     self.context = removeSecurityProxy(context)
     self.prm = IPrincipalRoleMap(self.context)
     super(UserAssignmentView, self).__init__(context, request)
Example #2
0
 def check_item(self, domain_class, status):
     principal = get_principal()
     roles = get_workspace_roles(principal)
     roles.extend(OBJECT_ROLES)
     for role in roles:
         statuses = self.workspace_config.get_status(
             role, domain_class, self.__name__)
         if statuses and status in statuses:
             return True
     return False
Example #3
0
 def _query(self, **kw):
     principal = get_principal()
     roles = get_workspace_roles()
     group_roles_domain_status = self.item_status_filter(kw, roles)
     session = Session()
     results = []
     count = 0
     for domain_class, status in group_roles_domain_status.iteritems():
         query = session.query(domain_class).filter(
             domain_class.status.in_(status)
             )
         if kw.get("filter_short_name", None):
             column = self.title_column(domain_class)
             query = query.filter(
                 """(lower(%s) LIKE '%%%s%%')""" %
                 (column, kw["filter_short_name"].lower())
                 )
         # The first page of the results is loaded the most number of times
         # The limit on the query below optimises for when no filter has
         # been applied by limiting the number of results returned.
         if (not kw.get("start", 0) and not kw.get("sort_on", None)):
             count = count + query.count()
             query = query.order_by(domain_class.status_date).limit(
                 kw.get("limit", 25))
         results.extend(query.all())
     object_roles_domain_status = self.item_status_filter(kw, OBJECT_ROLES)
     for domain_class, status in object_roles_domain_status.iteritems():
         query = session.query(domain_class).filter(
             domain_class.status.in_(status))
         if kw.get("filter_short_name", None):
             column = self.title_column(domain_class)
             query = query.filter(
                 """(lower(%s) LIKE '%%%s%%')""" %
                 (column, kw["filter_short_name"])
                 )
         if (not kw.get("start", 0) and not kw.get("sort_on", None)):
             count = count + query.count()
             query = query.order_by(domain_class.status_date).limit(
                 kw.get("limit", 25))
         for obj in query.all():
             prm = IPrincipalRoleMap(obj)
             for obj_role in OBJECT_ROLES:
                 if (prm.getSetting(obj_role, principal.id) == Allow and
                         obj not in results):
                     results.append(obj)
                     break
     # Sort items
     if (kw.get("sort_on", None) and kw.get("sort_dir", None)):
         rev = True if (kw.get("sort_dir") == "desc") else False
         results.sort(key=lambda x: getattr(x, str(kw.get("sort_on"))),
                      reverse=rev)
     if (kw.get("start", 0) and kw.get("sort_on", None)):
         count = len(results)
     return (results, count)
Example #4
0
 def count(self, read_from_cache=True):
     """Count of items in a container
     """
     principal = utils.get_principal()
     if (read_from_cache and principal.id in self.tab_count_cache.keys() and
             (self.tab_count_cache[principal.id].timestamp +
                 capi.workspace_tab_count_cache_refresh_time) > time.time()
         ):
         return self.tab_count_cache[principal.id].count
     results, count = self._query()
     return count
Example #5
0
 def check_item(self, domain_class, status):
     principal = get_principal()
     roles = get_workspace_roles(principal)
     roles.extend(OBJECT_ROLES)
     for role in roles:
         statuses = self.workspace_config.get_status(
             role, domain_class, self.__name__
             )
         if statuses and status in statuses:
             return True
     return False
Example #6
0
 def _query(self, **kw):
     principal = get_principal()
     roles = get_workspace_roles()
     group_roles_domain_status = self.item_status_filter(kw, roles)
     session = Session()
     results = []
     count = 0
     first_page = not kw.get("start", 0)
     reverse = True if (kw.get("sort_dir", "desc") == "desc") else False
     for domain_class, status in group_roles_domain_status.iteritems():
         query = session.query(domain_class).filter(
             domain_class.status.in_(status)
             )
         #filter on title
         query = self.filter_query(query, domain_class, kw)
         # Order results
         query = self.order_query(query, domain_class, kw, reverse)
         # The first page of the results is loaded the most number of times
         # The limit on the query below optimises for when no filter has
         # been applied by limiting the number of results returned.
         if first_page:
             count = count + query.count()
             query = query.limit(kw.get("limit", 25))
         results.extend(query.all())
     object_roles_domain_status = self.item_status_filter(kw, OBJECT_ROLES)
     for domain_class, status in object_roles_domain_status.iteritems():
         object_roles_results = []
         query = session.query(domain_class).filter(
             domain_class.status.in_(status)
             )
         #filter on title
         query = self.filter_query(query, domain_class, kw)
         # Order results
         query = self.order_query(query, domain_class, kw, reverse)
         for obj in query.all():
             prm = IPrincipalRoleMap(obj)
             for obj_role in OBJECT_ROLES:
                 if (prm.getSetting(obj_role, principal.id) == Allow and
                         obj not in results):
                     object_roles_results.append(obj)
                     break
         if first_page:
             count = count + len(object_roles_results)
         results.extend(object_roles_results)
     # Sort items
     if (kw.get("sort_on", None) and kw.get("sort_dir", None)):
         results.sort(key=lambda x: getattr(x, str(kw.get("sort_on"))),
                      reverse=reverse)
     if not first_page:
         count = len(results)
     return (results, count)
Example #7
0
 def _query(self, **kw):
     principal = utils.get_principal()
     roles = get_workspace_roles()
     group_roles_domain_status = self.item_status_filter(kw, roles)
     session = Session()
     results = []
     count = 0
     reverse = True if (kw.get("sort_dir", "desc") == "desc") else False
     for domain_class, status in group_roles_domain_status.iteritems():
         query = session.query(domain_class).filter(
             domain_class.status.in_(status)).enable_eagerloads(False)
         #filter on title
         query = self.filter_title(query, domain_class, kw)
         #filter on status_date
         query = self.filter_status_date(query, domain_class, kw)
         # Order results
         query = self.order_query(query, domain_class, kw, reverse)
         results.extend(query.all())
     for obj_role in ROLES_DIRECTLY_DEFINED_ON_OBJECTS:
         object_roles_domain_status = self.item_status_filter(
             kw, [obj_role])
         for domain_class, status in object_roles_domain_status.iteritems():
             query = session.query(domain_class).filter(
                 domain_class.status.in_(status)).enable_eagerloads(False)
             #filter on title
             query = self.filter_title(query, domain_class, kw)
             #filter on status_date
             query = self.filter_status_date(query, domain_class, kw)
             # Order results
             query = self.order_query(query, domain_class, kw, reverse)
             for obj in query.all():
                 if obj in results:
                     continue
                 prm = IPrincipalRoleMap(obj)
                 if (prm.getSetting(obj_role, principal.id) == Allow):
                     results.append(
                         contained(obj, self, self.string_key(obj)))
     results = [item for item in results if checkPermission(
         view_permission(item), contained(item, self, self.string_key(item)))]
     # Sort items
     if (kw.get("sort_on", None) and kw.get("sort_dir", None)):
         results.sort(key=lambda x: getattr(x, str(kw.get("sort_on"))),
             reverse=reverse)
     count = len(results)
     if not (kw.get("filter_title", None) or
             kw.get("filter_type", None) or
             kw.get("filter_status", None) or
             kw.get("filter_status_date", None)
         ):
         self.set_tab_count(principal.id, count)
     return (results, count)
Example #8
0
 def _query(self, **kw):
     principal = get_principal()
     roles = get_workspace_roles()
     group_roles_domain_status = self.item_status_filter(kw, roles)
     session = Session()
     results = []
     count = 0
     for domain_class, status in group_roles_domain_status.iteritems():
         query = session.query(domain_class).filter(
             domain_class.status.in_(status))
         if kw.get("filter_short_name", None):
             column = self.title_column(domain_class)
             query = query.filter("""(lower(%s) LIKE '%%%s%%')""" %
                                  (column, kw["filter_short_name"].lower()))
         # The first page of the results is loaded the most number of times
         # The limit on the query below optimises for when no filter has
         # been applied by limiting the number of results returned.
         if (not kw.get("start", 0) and not kw.get("sort_on", None)):
             count = count + query.count()
             query = query.order_by(domain_class.status_date).limit(
                 kw.get("limit", 25))
         results.extend(query.all())
     object_roles_domain_status = self.item_status_filter(kw, OBJECT_ROLES)
     for domain_class, status in object_roles_domain_status.iteritems():
         query = session.query(domain_class).filter(
             domain_class.status.in_(status))
         if kw.get("filter_short_name", None):
             column = self.title_column(domain_class)
             query = query.filter("""(lower(%s) LIKE '%%%s%%')""" %
                                  (column, kw["filter_short_name"]))
         if (not kw.get("start", 0) and not kw.get("sort_on", None)):
             count = count + query.count()
             query = query.order_by(domain_class.status_date).limit(
                 kw.get("limit", 25))
         for obj in query.all():
             prm = IPrincipalRoleMap(obj)
             for obj_role in OBJECT_ROLES:
                 if (prm.getSetting(obj_role, principal.id) == Allow
                         and obj not in results):
                     results.append(obj)
                     break
     # Sort items
     if (kw.get("sort_on", None) and kw.get("sort_dir", None)):
         rev = True if (kw.get("sort_dir") == "desc") else False
         results.sort(key=lambda x: getattr(x, str(kw.get("sort_on"))),
                      reverse=rev)
     if (kw.get("start", 0) and kw.get("sort_on", None)):
         count = len(results)
     return (results, count)
Example #9
0
 def __str__(self):
     tabs_utility = getUtility(IWorkspaceTabsUtility)
     domain_class = self.context.__class__
     status = self.context.status
     principal = get_principal()
     roles = get_workspace_roles(principal)
     tab = None
     for role in roles:
         tab = tabs_utility.getTab(role, domain_class, status)
         if tab:
             base_url = ui_utils.url.absoluteURL(getSite(), self.request)
             key = workspace.stringKey(self.context)
             return '%s/workspace/documents/%s/%s' % (base_url, tab, key)
     else:
         return None
 def __str__(self):
     tabs_utility = getUtility(IWorkspaceTabsUtility)
     domain_class = self.context.__class__
     status = self.context.status
     principal = get_principal()
     roles = get_workspace_roles(principal)
     tab = None
     for role in roles:
         tab = tabs_utility.getTab(role, domain_class, status)
         if tab:
             base_url = ui_utils.url.absoluteURL(getSite(), self.request)
             key = workspace.stringKey(self.context)
             return '%s/workspace/documents/%s/%s' % (base_url, tab, key)
     else:
         return None
Example #11
0
 def _query(self, **kw):
     principal = get_principal()
     roles = get_workspace_roles(principal)
     group_roles_domain_status = self.item_status_filter(kw, roles)
     session = Session()
     results = []
     for domain_class, status in group_roles_domain_status.iteritems():
         query = session.query(domain_class).filter(
             domain_class.status.in_(status)
             )
         if kw.get("filter_short_name", None):
             column = self.title_column(domain_class)
             query = query.filter(
                 """(lower(%s) LIKE '%%%s%%')""" %
                 (column, kw["filter_short_name"].lower())
                 )
         results.extend(query.all())
     object_roles_domain_status = self.item_status_filter(kw, OBJECT_ROLES)
     for domain_class, status in object_roles_domain_status.iteritems():
         query = session.query(domain_class).filter(
             domain_class.status.in_(status))
         if kw.get("filter_short_name", None):
             column = self.title_column(domain_class)
             query = query.filter(
                 """(lower(%s) LIKE '%%%s%%')""" %
                 (column, kw["filter_short_name"])
                 )
         for obj in query.all():
             prm = IPrincipalRoleMap(obj)
             for obj_role in OBJECT_ROLES:
                 if (prm.getSetting(obj_role, principal.id) == Allow and
                         obj not in results
                     ):
                     results.append(obj)
                     break
     # Sort items
     if kw.get("sort_on", None):
         if kw.get("sort_dir", None):
             rev = True if (kw.get("sort_dir") == "desc") else False
             results.sort(key=lambda x: getattr(x, str(kw.get("sort_on"))),
                          reverse=rev)
     return results
Example #12
0
 def get_status(self, item_type):
     workspace_config = component.getUtility(IWorkspaceTabsUtility)
     principal = get_principal()
     roles = get_workspace_roles(principal)
     roles.extend(OBJECT_ROLES)
     domain_class = workspace_config.get_domain(item_type)
     results = set()
     for role in roles:
         status = workspace_config.get_status(role, domain_class,
                                              self.context.__name__)
         if status:
             for s in status:
                 results.add(s)
     translated = dict()
     for result in results:
         workflow = IWorkflow(domain_class())
         status_title = translate(str(workflow.get_state(result).title),
                                  domain="bungeni",
                                  context=self.request)
         translated[result] = status_title
     return translated
Example #13
0
 def get_item_types(self):
     workspace_config = component.getUtility(IWorkspaceTabsUtility)
     principal = get_principal()
     roles = get_workspace_roles(principal)
     roles.extend(OBJECT_ROLES)
     domains = []
     for role in roles:
         dom = workspace_config.get_role_domains(role,
                                                 self.context.__name__)
         if dom:
             for key in dom:
                 if key not in domains:
                     domains.append(key)
     result = dict([("", "-")])
     for domain in domains:
         value = workspace_config.get_type(domain)
         if value:
             descriptor = queryModelDescriptor(domain)
             name = descriptor.display_name if descriptor else value
             result[value] = translate(name, context=self.request)
     return result
Example #14
0
 def get_item_types(self):
     workspace_config = component.getUtility(IWorkspaceTabsUtility)
     principal = get_principal()
     roles = get_workspace_roles(principal)
     roles.extend(OBJECT_ROLES)
     domains = []
     for role in roles:
         dom = workspace_config.get_role_domains(
             role, self.context.__name__
             )
         if dom:
             for key in dom:
                 if key not in domains:
                     domains.append(key)
     result = dict([("", "-")])
     for domain in domains:
         value = workspace_config.get_type(domain)
         if value:
             descriptor = queryModelDescriptor(domain)
             name = descriptor.display_name if descriptor else value
             result[value] = translate(name, context=self.request)
     return result
Example #15
0
 def _query(self):
     principal = get_principal()
     roles = get_workspace_roles(principal)
     workspace_tabs = component.getUtility(IWorkspaceTabsUtility)
     domain_status = {}
     for role in roles:
         dom_stat = workspace_tabs.getDomainAndStatuses(role, self.__name__)
         if dom_stat:
             for key in dom_stat.keys():
                 if key in domain_status.keys():
                     domain_status[key].extend(dom_stat[key])
                 else:
                     domain_status[key] = dom_stat[key]
     session = Session()
     results = []
     for domain_class in domain_status.keys():
         query = session.query(domain_class).filter(
             domain_class.status.in_(domain_status[domain_class]))
         results.extend(query.all())
     results.sort(key=lambda x: x.status_date, reverse=True)
     for result in results:
         yield result
Example #16
0
 def _query( self ):
     principal = get_principal()
     roles = get_workspace_roles(principal)
     workspace_tabs = component.getUtility(IWorkspaceTabsUtility)
     domain_status = {}
     for role in roles:
         dom_stat = workspace_tabs.getDomainAndStatuses(role, self.__name__)
         if dom_stat:
             for key in dom_stat.keys():
                 if key in domain_status.keys():
                     domain_status[key].extend(dom_stat[key])
                 else:
                     domain_status[key] = dom_stat[key]    
     session = Session()
     results = []
     for domain_class in domain_status.keys():
         query = session.query(domain_class).filter(
                        domain_class.status.in_(domain_status[domain_class]))
         results.extend(query.all())
     results.sort(key = lambda x: x.status_date, reverse=True)
     for result in results:
         yield result
Example #17
0
 def get_status(self, item_type):
     workspace_config = component.getUtility(IWorkspaceTabsUtility)
     principal = get_principal()
     roles = get_workspace_roles(principal)
     roles.extend(OBJECT_ROLES)
     domain_class = workspace_config.get_domain(item_type)
     results = set()
     for role in roles:
         status = workspace_config.get_status(
             role, domain_class, self.context.__name__)
         if status:
             for s in status:
                 results.add(s)
     translated = dict()
     for result in results:
         workflow = IWorkflow(domain_class())
         status_title = translate(
             str(workflow.get_state(result).title),
             domain="bungeni",
             context=self.request
             )
         translated[result] = status_title
     return translated
Example #18
0
 def _query(self, **kw):
     principal = get_principal()
     roles = get_workspace_roles(principal)
     group_roles_domain_status = self.item_status_filter(kw, roles)
     session = Session()
     results = []
     for domain_class, status in group_roles_domain_status.iteritems():
         query = session.query(domain_class).filter(
             domain_class.status.in_(status))
         if kw.get("filter_short_name", None):
             column = self.title_column(domain_class)
             query = query.filter("""(lower(%s) LIKE '%%%s%%')""" %
                                  (column, kw["filter_short_name"].lower()))
         results.extend(query.all())
     object_roles_domain_status = self.item_status_filter(kw, OBJECT_ROLES)
     for domain_class, status in object_roles_domain_status.iteritems():
         query = session.query(domain_class).filter(
             domain_class.status.in_(status))
         if kw.get("filter_short_name", None):
             column = self.title_column(domain_class)
             query = query.filter("""(lower(%s) LIKE '%%%s%%')""" %
                                  (column, kw["filter_short_name"]))
         for obj in query.all():
             prm = IPrincipalRoleMap(obj)
             for obj_role in OBJECT_ROLES:
                 if (prm.getSetting(obj_role, principal.id) == Allow
                         and obj not in results):
                     results.append(obj)
                     break
     # Sort items
     if kw.get("sort_on", None):
         if kw.get("sort_dir", None):
             rev = True if (kw.get("sort_dir") == "desc") else False
             results.sort(key=lambda x: getattr(x, str(kw.get("sort_on"))),
                          reverse=rev)
     return results
Example #19
0
    def workspace_search(self):
        """ Search in workspace section, based on views from bungeni.ui.viewlets.workspace
        """
        application = common.get_application()
        parliament = get_current_parliament(None)
        parliament.__parent__ = application
        principal = get_principal()
        roles = common.get_context_roles(parliament, principal)

        # minister role, filtering by states and object_type and ministry_id
        if not roles:
            user_id = get_db_user_id()
            government_id = get_current_parliament_governments(
                parliament)[0].group_id
            ministries = get_ministries_for_user_in_government(
                user_id, government_id)
            if ministries:
                states = workspace.MinistryArchiveViewlet.states + \
                         workspace.OralMinistryQuestionsViewlet.states + \
                         workspace.WrittenMinistryQuestionsViewlet.states + \
                         workspace.InProgressMinistryItemsViewlet.states
                states = set(states)

                ministry_ids = [m.group_id for m in ministries]

                # filter by object_type (questions only)
                type_query = self.searcher.query_field('object_type',
                                                       "Question")
                query = self.searcher.query_composite(self.searcher.OP_AND, \
                                                       (self.query, type_query,))

                subqueries = []

                for state in states:
                    subqueries.append(
                        self.searcher.query_field('status', state))

                state_query = self.searcher.query_composite(
                    self.searcher.OP_OR, subqueries)
                query = self.searcher.query_composite(self.searcher.OP_AND, \
                                                           (query, state_query,))

                #filter for ministries
                ministries_queries = []

                for mid in ministry_ids:
                    ministries_queries.append(
                        self.searcher.query_field('ministry_id', str(mid)))

                m_query = self.searcher.query_composite(
                    self.searcher.OP_OR, ministries_queries)
                query = self.searcher.query_composite(self.searcher.OP_AND, \
                                                           (query, m_query,))

                try:
                    results = self.searcher.search(
                        query, 0, self.searcher.get_doccount())
                except:
                    results = []

                return list(results)

        # filtering by states and owner
        if 'bungeni.MP' in roles:
            states = workspace.MPItemActionRequiredViewlet.states + \
                     workspace.MPItemDraftViewlet.states + \
                     workspace.MPItemInProgressViewlet.states + \
                     workspace.ItemArchiveViewlet.states
            states = set(states)
            # filter by owner of PI
            owner_query = self.searcher.query_field('owner',
                                                    str(get_db_user_id()))
            query = self.searcher.query_composite(self.searcher.OP_AND, \
                                                       (self.query, owner_query,))

            subqueries = []

            for state in states:
                subqueries.append(self.searcher.query_field('status', state))

            state_query = self.searcher.query_composite(
                self.searcher.OP_OR, subqueries)
            query = self.searcher.query_composite(self.searcher.OP_AND, \
                                                       (query, state_query,))

            try:
                results = self.searcher.search(query, 0,
                                               self.searcher.get_doccount())
            except:
                results = []

            return list(results)

        # filtering by states
        if 'bungeni.Clerk' in roles:
            states = workspace.ClerkItemActionRequiredViewlet.states + \
                     workspace.ClerkItemsWorkingDraftViewlet.states + \
                     workspace.ClerkReviewedItemViewlet.states + \
                     workspace.ItemsApprovedViewlet.states + \
                     workspace.ItemsPendingScheduleViewlet.states + \
                     workspace.ItemsScheduledViewlet.states + \
                     workspace.AllItemArchiveViewlet.states

            states = set(states)

            subqueries = []

            for state in states:
                subqueries.append(self.searcher.query_field('status', state))

            state_query = self.searcher.query_composite(
                self.searcher.OP_OR, subqueries)
            query = self.searcher.query_composite(self.searcher.OP_AND, \
                                                       (self.query, state_query,))

            try:
                results = self.searcher.search(query, 0,
                                               self.searcher.get_doccount())
            except:
                results = []

            return list(results)
        # no results
        return False
Example #20
0
    def workspace_search(self):
        """ Search in workspace section, based on views from bungeni.ui.viewlets.workspace
        """
        application = common.get_application()
        parliament = get_current_parliament(None)
        parliament.__parent__ = application
        principal = get_principal()
        roles = common.get_context_roles(parliament, principal)

        # minister role, filtering by states and object_type and ministry_id
        if not roles:
            user_id = get_db_user_id()
            government_id = get_current_parliament_governments(parliament)[0].group_id
            ministries = get_ministries_for_user_in_government(user_id, government_id)
            if ministries:
                states = workspace.MinistryArchiveViewlet.states + \
                         workspace.OralMinistryQuestionsViewlet.states + \
                         workspace.WrittenMinistryQuestionsViewlet.states + \
                         workspace.InProgressMinistryItemsViewlet.states
                states = set(states)
                
                ministry_ids = [m.group_id for m in ministries]
                
                # filter by object_type (questions only)
                type_query = self.searcher.query_field('object_type', "Question")
                query = self.searcher.query_composite(self.searcher.OP_AND, \
                                                       (self.query, type_query,))
                
                subqueries = []

                for state in states:
                    subqueries.append(self.searcher.query_field('status', state))
                    
                state_query = self.searcher.query_composite(self.searcher.OP_OR, subqueries)
                query = self.searcher.query_composite(self.searcher.OP_AND, \
                                                           (query, state_query,))
                
                #filter for ministries
                ministries_queries = []
                
                for mid in ministry_ids:
                    ministries_queries.append(self.searcher.query_field('ministry_id', str(mid)))
                    
                m_query = self.searcher.query_composite(self.searcher.OP_OR, ministries_queries)
                query = self.searcher.query_composite(self.searcher.OP_AND, \
                                                           (query, m_query,))
                
                try:
                    results = self.searcher.search(query, 0, self.searcher.get_doccount())
                except:
                    results = []
                
                return list(results)
        
        # filtering by states and owner
        if 'bungeni.MP' in roles:
            states = workspace.MPItemActionRequiredViewlet.states + \
                     workspace.MPItemDraftViewlet.states + \
                     workspace.MPItemInProgressViewlet.states + \
                     workspace.ItemArchiveViewlet.states
            states = set(states)
            # filter by owner of PI
            owner_query = self.searcher.query_field('owner', str(get_db_user_id()))
            query = self.searcher.query_composite(self.searcher.OP_AND, \
                                                       (self.query, owner_query,))
            
            subqueries = []

            for state in states:
                subqueries.append(self.searcher.query_field('status', state))
                
            state_query = self.searcher.query_composite(self.searcher.OP_OR, subqueries)
            query = self.searcher.query_composite(self.searcher.OP_AND, \
                                                       (query, state_query,))
            
            try:
                results = self.searcher.search(query, 0,
                self.searcher.get_doccount())
            except:
                results = []
                
            return list(results)
            
        # filtering by states
        if 'bungeni.Clerk' in roles:
            states = workspace.ClerkItemActionRequiredViewlet.states + \
                     workspace.ClerkItemsWorkingDraftViewlet.states + \
                     workspace.ClerkReviewedItemViewlet.states + \
                     workspace.ItemsApprovedViewlet.states + \
                     workspace.ItemsPendingScheduleViewlet.states + \
                     workspace.ItemsScheduledViewlet.states + \
                     workspace.AllItemArchiveViewlet.states
                     
            states = set(states)
            
            subqueries = []

            for state in states:
                subqueries.append(self.searcher.query_field('status', state))
                
            state_query = self.searcher.query_composite(self.searcher.OP_OR, subqueries)
            query = self.searcher.query_composite(self.searcher.OP_AND, \
                                                       (self.query, state_query,))
            
            try:
                results = self.searcher.search(query, 0,
                self.searcher.get_doccount())
            except:
                results = []
                
            return list(results)
        # no results
        return False