Exemplo n.º 1
0
def handleSchedule(object, event):
    """ move scheduled items from to be scheduled state to schedule when draft 
    agenda is finalised and vice versa
    """
    session = Session()
    s = removeSecurityProxy(object)
    sitting = session.query(domain.GroupSitting
        ).options(eagerload("group_sitting_type"), eagerload("item_schedule")
        ).get(s.group_sitting_id)
    schedulings = map(removeSecurityProxy, sitting.item_schedule)
    if sitting.status == "draft_agenda":
        for sch in schedulings:
            if sch.item.type != "heading":
                wfc = IWorkflowController(sch.item)
                wf = wfc.workflow
                next_state = get_states(sch.item.type, tagged=["tobescheduled"])
                for transition_id in wfc.getSystemTransitionIds():
                    t = wf.get_transition(transition_id)
                    if t.destination in next_state:
                        #TODO find out why firetransition fails for reschedule even 
                        #when the user has requisite permissions
                        wfc.fireTransition(transition_id, check_security=False)
                        break
    elif sitting.status == "published_agenda":
        for sch in schedulings:
            if sch.item.type != "heading":
                wfc = IWorkflowController(sch.item)
                wf = wfc.workflow
                next_state = get_states(sch.item.type, tagged=["scheduled"])
                for transition_id in wfc.getSystemTransitionIds():
                    t = wf.get_transition(transition_id)
                    if t.destination in next_state:
                        wfc.fireTransition(transition_id, check_security=False)
                        break
Exemplo n.º 2
0
def get_archived_states():
    return \
        get_states("agendaitem", tagged=["terminal"]) + \
        get_states("bill", tagged=["terminal"]) + \
        get_states("motion", tagged=["terminal"]) + \
        get_states("question", tagged=["terminal"]) + \
        get_states("tableddocument", tagged=["terminal"])
Exemplo n.º 3
0
 def update(self):
     user_id = self.context.user_id
     parliament_id = self.context.group_id
     session = Session()
     # add cosigned items
     signed_pi_ids = [sgn.item_id for sgn in
         session.query(domain.Signatory).filter(
             sql.and_(domain.Signatory.user_id == user_id,
                 domain.Signatory.status.in_(
                         get_states("signatory", tagged=["public"])
                     ),
             )
         ).all()
     ]
     if len(signed_pi_ids) > 0:
         self.query = self.query.union(
             session.query(domain.ParliamentaryItem).filter(
                 sql.and_(
                     domain.ParliamentaryItem.parliament_id == parliament_id,
                     domain.ParliamentaryItem.status.in_(self.states),
                     domain.ParliamentaryItem.parliamentary_item_id.in_(
                         signed_pi_ids
                     )
                 )
             )
         )
     self.query = self.query.order_by(
         domain.ParliamentaryItem.parliamentary_item_id.desc()
     )
Exemplo n.º 4
0
def get_sitting_items(sitting, request, include_actions=False):
    items = []

    if sitting.status in get_states("groupsitting", keys=["draft_agenda", "published_agenda"]):
        order = "planned_order"
    else:
        order = "real_order"

    schedulings = map(removeSecurityProxy, sitting.items.batch(order_by=order, limit=None))
    site_url = url.absoluteURL(getSite(), request)
    for scheduling in schedulings:
        item = ProxyFactory(location_wrapped(scheduling.item, sitting))

        props = IDCDescriptiveProperties.providedBy(item) and item or IDCDescriptiveProperties(item)

        discussions = tuple(scheduling.discussions.values())
        discussion = discussions and discussions[0] or None
        truncated_discussion = None
        if (discussion is not None) and (discussion.body_text is not None):
            # truncate discussion to first hundred characters
            t_discussion = discussion.body_text[0:100]
            try:
                # truncate discussion to first two lines
                index = t_discussion.index("<br>")
                index2 = t_discussion.index("<br>", index + 4)
                truncated_discussion = t_discussion[0:index2] + "..."
            except ValueError:
                truncated_discussion = t_discussion + "..."
        info = IWorkflowInfo(item, None)
        state_title = info.workflow().workflow.states[item.status].title

        record = {
            "title": props.title,
            "description": props.description,
            "name": stringKey(scheduling),
            "status": item.status,
            "type": item.type.capitalize,
            "t": item.type,
            "state_title": state_title,
            #'category_id': scheduling.category_id,
            #'category': scheduling.category,
            "discussion": discussion,
            "truncated_discussion": truncated_discussion,
            "delete_url": "%s/delete" % url.absoluteURL(scheduling, request),
            "url": url.set_url_context(site_url + ("/business/%ss/obj-%s" % (item.type, item.parliamentary_item_id))),
        }

        if include_actions:
            record["actions"] = get_scheduling_actions(scheduling, request)
            record["workflow"] = get_workflow_actions(item, request)

            discussion_actions = get_discussion_actions(discussion, request)
            if discussion_actions:
                assert len(discussion_actions) == 1
                record["discussion_action"] = discussion_actions[0]
            else:
                record["discussion_action"] = None
        items.append(record)
    return items
Exemplo n.º 5
0
 def is_workflowed_and_draft(instance):
     """is item workflowed, and is so is it in a logical draft state?
     """
     if IWorkflowed.providedBy(instance):
         tagged_key = instance.__class__.__name__.lower()
         draft_states = get_states(tagged_key, tagged=["draft"])
         return instance.status in draft_states
     return False
Exemplo n.º 6
0
def assignable_tags():
    return [state for state in itertools.chain(
        *[
            get_states(
                pi_type, 
                not_tagged=["private", "fail", "terminal"]
            )
            for pi_type in TAG_MAPPINGS.keys()
        ]
    )]
Exemplo n.º 7
0
 def get_sittings(self):
     formatter = self.request.locale.dates.getFormatter("date", "full")
     session = Session()
     query = (
         session.query(domain.GroupSitting)
         .filter(
             sql.and_(
                 schema.sittings.c.status.in_(get_states("groupsitting", tagged=["public"])),
                 sql.between(schema.sittings.c.start_date, self.start_date, self.end_date),
             )
         )
         .order_by(schema.sittings.c.start_date)
         .options(
             eagerload("group"),
             # eagerload('sitting_type'),
             eagerload("item_schedule"),
             eagerload("item_schedule.item"),
         )
     )
     sittings = query.all()
     day = u""
     day_list = []
     s_dict = {}
     for sitting in sittings:
         sday = formatter.format(sitting.start_date)
         if sday != day:
             s_list = []
             day = sday
             if s_dict:
                 day_list.append(s_dict)
             s_dict = {}
         if sitting.group.type == "parliament":
             _url = url.set_url_context("/business/sittings/obj-%i" % (sitting.sitting_id))
         elif sitting.group.type == "committee":
             _url = url.set_url_context(
                 "/business/committees/obj-%i/sittings/obj-%i" % (sitting.group.group_id, sitting.sitting_id)
             )
         else:
             _url = "#"
         s_list.append(
             {
                 "start": sitting.start_date.strftime("%H:%M"),
                 "end": sitting.end_date.strftime("%H:%M"),
                 "type": sitting.group.type,
                 "name": sitting.group.short_name,
                 "url": _url,
                 "items": self.get_sitting_items(sitting),
             }
         )
         s_dict["day"] = day
         s_dict["sittings"] = s_list
     else:
         if s_dict:
             day_list.append(s_dict)
     return day_list
Exemplo n.º 8
0
 def get_sittings(self):
     formatter = self.request.locale.dates.getFormatter('date', 'full') 
     session = Session()
     query = session.query(domain.GroupSitting).filter(
         sql.and_(
             schema.group_sittings.c.status.in_(get_states('groupsitting',
                 tagged=['public'])
             ),
             sql.between(
                 schema.group_sittings.c.start_date,
                 self.start_date,
                 self.end_date))).order_by(
                     schema.group_sittings.c.start_date).options(
                     eagerload('group'), 
                     #eagerload('sitting_type'),
                     eagerload('item_schedule'), 
                     eagerload('item_schedule.item')
         )
     sittings = query.all()
     day = u''
     day_list = []
     s_dict = {}
     for sitting in sittings:
         sday = formatter.format(sitting.start_date)
         if sday != day:
             s_list = []
             day = sday
             if s_dict:
                 day_list.append(s_dict)
             s_dict = {}
         if sitting.group.type == 'parliament':
             _url = url.set_url_context('/business/sittings/obj-%i' % (
                  sitting.group_sitting_id))
         elif sitting.group.type == 'committee':
             _url = url.set_url_context(
                 '/business/committees/obj-%i/sittings/obj-%i'
                 % (sitting.group.group_id, sitting.group_sitting_id))
         else:
             _url ='#'
         s_list.append({
             'start': sitting.start_date.strftime("%H:%M"),
             'end' : sitting.end_date.strftime("%H:%M"),
             'type' : sitting.group.type,
             'name' : sitting.group.short_name,
             'url' : _url, 
             'items' : self.get_sitting_items(sitting),
             })
         s_dict['day'] = day
         s_dict['sittings'] = s_list
     else:
         if s_dict:
             day_list.append(s_dict)
     return day_list
Exemplo n.º 9
0
def get_sitting_items(sitting, request, include_actions=False):
    items = []

    if sitting.status in get_states("groupsitting", 
                                keys=["draft_agenda", "published_agenda"]):
        order = "planned_order"
    else:
        order = "real_order"

    schedulings = map(
        removeSecurityProxy,
        sitting.items.batch(order_by=order, limit=None))
    site_url = url.absoluteURL(getSite(), request)
    for scheduling in schedulings:
        item = ProxyFactory(location_wrapped(scheduling.item, sitting))
       
        props = IDCDescriptiveProperties.providedBy(item) and item or \
                IDCDescriptiveProperties(item)

        discussions = tuple(scheduling.discussions.values())
        discussion = discussions and discussions[0] or None

        info = IWorkflowInfo(item, None)
        state_title = info.workflow().workflow.states[item.status].title
        
        record = {
            'title': props.title,
            'description': props.description,
            'name': stringKey(scheduling),
            'status': item.status,
            'type': item.type.capitalize,
            't':item.type,
            'state_title': state_title,
            #'category_id': scheduling.category_id,
            #'category': scheduling.category,
            'discussion': discussion,
            'delete_url': "%s/delete" % url.absoluteURL(scheduling, request),
            'url': url.set_url_context(site_url+('/business/%ss/obj-%s' % (item.type, item.parliamentary_item_id)))}
        
        if include_actions:
            record['actions'] = get_scheduling_actions(scheduling, request)
            record['workflow'] = get_workflow_actions(item, request)

            discussion_actions = get_discussion_actions(discussion, request)
            if discussion_actions:
                assert len(discussion_actions) == 1
                record['discussion_action'] = discussion_actions[0]
            else:
                record['discussion_action'] = None
        items.append(record)
    return items
Exemplo n.º 10
0
 def get_sitting_items(self, sitting):
     s_list = []
     if sitting.status in get_states('groupsitting',tagged=['agendaprivate']):
         return s_list
     else:
         for schedule in sitting.item_schedule:
             s_list.append({
                 'name': schedule.item.short_name,
                 'status' : misc.get_wf_state(schedule.item),
                 'url' : url.set_url_context(('/business/' +
                         schedule.item.type + 's/obj-' + 
                     str(schedule.item.parliamentary_item_id))),
                 'item_type' : schedule.item.type,
                  })
         return s_list
Exemplo n.º 11
0
 def get_items(self):
     session = Session()
     where_clause = sql.and_(
             schema.sittings.c.status.in_(get_states(
                                 "groupsitting", tagged=["public"])),
             sql.between(
                 schema.sittings.c.start_date,
                 self.start_date,
                 self.end_date))
         
     query = session.query(domain.ItemSchedule).join(
         domain.GroupSitting
         ).filter( 
         where_clause).order_by(schema.sittings.c.start_date).options(
                 eagerload('sitting'), eagerload('item'),
                 #eagerload('sitting.sitting_type'),
                 lazyload('item.owner'))
     self.itemschedules = query.all()
Exemplo n.º 12
0
 def get_sitting_items(self, sitting):
     s_list = []
     if sitting.status in get_states('groupsitting',tagged=['agendaprivate']):
         return s_list
     else:
     # !+DCPROPERTIES(murithi, april-2011) Factor out properties+i18n to DC
         for schedule in sitting.item_schedule:
             descriptor = queryModelDescriptor(schedule.item.__class__)
             s_list.append({
                 'name': IDCDescriptiveProperties(schedule.item).title,
                 'status' : str(misc.get_wf_state(schedule.item))
                 ,
                 'url' : url.set_url_context(('/business/' +
                         schedule.item.type + 's/obj-' + 
                     str(schedule.item.parliamentary_item_id))),
                 'item_type': schedule.item.type,
                 'item_type_title' : (
                     descriptor.display_name if descriptor else
                         schedule.item.type
                 ),
             })
         return s_list
Exemplo n.º 13
0
class OralMinistryQuestionsViewlet(MinistryItemsViewlet):
    view_id = "ministry-oral-questions"
    view_title = _("oral questions")
    states = get_states("question", tagged=["oral"])
    response_types = ["O"]
Exemplo n.º 14
0
class SchedulableQuestionsViewlet(SchedulableItemsViewlet):
    model = domain.Question
    name = _('Questions')
    view_name = "question"
    states = get_states("question", tagged=["tobescheduled"])
Exemplo n.º 15
0
class SchedulableMotionsViewlet(SchedulableItemsViewlet):
    model = domain.Motion
    name = _('Motions')
    view_name = "motion"
    states = get_states("motion", tagged=["tobescheduled"])
Exemplo n.º 16
0
class SchedulableTabledDocumentsViewlet(SchedulableItemsViewlet):
    model = domain.TabledDocument
    name = _('Tabled documents')
    view_name = "tableddocument"
    states = get_states("tableddocument", tagged=["tobescheduled"])
Exemplo n.º 17
0
class DraftSittingsViewlet(WorkspaceViewlet):
    """The "agendas/minutes" tab in the workspace/pi view for the Clerk.
    """

    # evoque
    render = z3evoque.ViewTemplateFile("workspace_viewlets.html#sittings")

    # zpt
    #render = ViewPageTemplateFile("templates/workspace_sitting_viewlet.pt")

    view_id = "sitting-draft"
    view_title = _("agendas/minutes")
    states = get_states("groupsitting", tagged=["workspace"])

    def _get_items(self):
        data_list = []
        results = self.query.all()
        formatter = self.get_date_formatter("date", "long")
        time_formatter = self.get_date_formatter("time", "short")
        for result in results:
            data = {}
            data["subject"] = result.short_name
            # this tab appears in the workspace pi/ view...
            data["url"] = url.set_url_context(
                "../../scheduling/sittings/obj-%i/schedule" % result.sitting_id)
            # Note: same UI is also displayed at: 
            # /business/sittings/obj-%i/schedule % result.sitting_id
            data["items"] = ""
            data["status"] = misc.get_wf_state(result)
            data["status_date"] = formatter.format(result.status_date)
            data["owner"] = ""
            data["type"] = result.group.type
            data["group"] = u"%s %s" % (
                    result.group.type.capitalize(), result.group.short_name)
            data["time_from_to"] = (
                    time_formatter.format(result.start_date),
                    time_formatter.format(result.end_date))
            data["date"] = formatter.format(result.start_date)
            if result.venue:
                data["venue"] = _(result.venue.short_name)
            #else:
            #    date["venue"] = ""
            if type(result) == domain.Question:
                data["to"] = result.ministry.short_name
            else:
                data["to"] = ""
            # past, present, future
            today = datetime.datetime.today().date()
            startday = result.start_date.date()
            if today == startday:
                data["css_class"] = "present"
            elif today > startday:
                data["css_class"] = "past"
            else:
                data["css_class"] = "future"
            data_list.append(data)
        return data_list

    def update(self):
        """Refresh the query
        """
        session = Session()
        qfilter = domain.GroupSitting.status.in_(self.states)
        sittings = session.query(domain.GroupSitting).filter(
                qfilter).order_by(domain.GroupSitting.start_date.desc()
                    ).options(
                eagerload("group")
                )
        self.query = sittings
        self.items = self._get_items()
Exemplo n.º 18
0
class SchedulableBillsViewlet(SchedulableItemsViewlet):
    model = domain.Bill
    name = _('Bills')
    view_name = "bill"
    states = get_states("bill", tagged=["tobescheduled"])
Exemplo n.º 19
0
class MinistryArchiveViewlet(MinistryItemsViewlet):
    view_id = "items-archived"
    view_title = _("archived items")
    # Ministry archive only includes Questions in a public terminal state
    states = get_states("question",
                    tagged=["public", "terminal"], conjunction="AND")
Exemplo n.º 20
0
class SchedulableAgendaItemsViewlet(SchedulableItemsViewlet):
    model = domain.AgendaItem
    name = _('Agenda items')
    view_name = "agendaitem"
    visible = True
    states = get_states("agendaitem", tagged=["tobescheduled"])

    def get_group_id(self):
        parent = self.context
        while parent is not None:
            group_id = getattr(parent, 'group_id', None)
            if group_id:
                return group_id
            else:
                parent = parent.__parent__
        raise ValueError("Unable to determine group.")

    def update(self):
        need('yui-dragdrop')
        need('yui-container')

        session = Session()
        group_id = self.get_group_id()

        items = tuple(
            session.query(self.model).filter(
                sql.and_(self.model.status.in_(self.states),
                         self.model.group_id == group_id)))
        sitting = self._parent._parent.context
        scheduled_item_ids = [item.item_id for item in sitting.item_schedule]
        # add location to items
        gsm = component.getSiteManager()
        adapter = gsm.adapters.lookup(
            (interface.implementedBy(self.model), interface.providedBy(self)),
            ILocation)

        items = [adapter(item, None) for item in items]

        # for each item, format dictionary for use in template
        self.items = [
            {
                'title':
                properties.title,
                'name':
                item.__class__.__name__,
                'description':
                properties.description,
                #'date': _(u"$F", mapping={'F':
                #           datetimedict.fromdatetime(item.changes[-1].date)}),
                'date':
                item.changes[-1].date_active,
                'state':
                _(IWorkflow(item).workflow.states[item.status].title),
                'id':
                item.parliamentary_item_id,
                'class': (item.parliamentary_item_id in scheduled_item_ids)
                and "dd-disable" or "",
                'url':
                url.set_url_context(url.absoluteURL(item, self.request))
            }
            for (item,
                 properties) in [(item,
                                  (IDCDescriptiveProperties.providedBy(item)
                                   and item or IDCDescriptiveProperties(item)))
                                 for item in items]
        ]
Exemplo n.º 21
0
class WrittenMinistryQuestionsViewlet(MinistryItemsViewlet):
    view_id = "ministry-written-questions"
    view_title = _("written questions")
    states = get_states("question", tagged=["written"])
    response_types = ["W"]
Exemplo n.º 22
0
def get_sitting_items(sitting, request, include_actions=False):
    items = []

    if sitting.status in get_states("groupsitting",
                                    keys=["draft_agenda", "published_agenda"]):
        order = "planned_order"
    else:
        order = "real_order"

    schedulings = map(removeSecurityProxy,
                      sitting.items.batch(order_by=order, limit=None))
    site_url = url.absoluteURL(getSite(), request)
    for scheduling in schedulings:
        item = ProxyFactory(location_wrapped(scheduling.item, sitting))

        props = IDCDescriptiveProperties.providedBy(item) and item or \
                IDCDescriptiveProperties(item)

        discussions = tuple(scheduling.discussions.values())
        discussion = discussions and discussions[0] or None
        truncated_discussion = None
        if ((discussion is not None) and (discussion.body_text is not None)):
            #truncate discussion to first hundred characters
            t_discussion = discussion.body_text[0:100]
            try:
                #truncate discussion to first two lines
                index = t_discussion.index("<br>")
                index2 = t_discussion.index("<br>", index + 4)
                truncated_discussion = t_discussion[0:index2] + "..."
            except ValueError:
                truncated_discussion = t_discussion + "..."
        info = IWorkflowInfo(item, None)
        state_title = info.workflow().workflow.states[item.status].title

        record = {
            'title':
            props.title,
            'description':
            props.description,
            'name':
            stringKey(scheduling),
            'status':
            item.status,
            'type':
            item.type.capitalize,
            't':
            item.type,
            'state_title':
            state_title,
            #'category_id': scheduling.category_id,
            #'category': scheduling.category,
            'discussion':
            discussion,
            'truncated_discussion':
            truncated_discussion,
            'delete_url':
            "%s/delete" % url.absoluteURL(scheduling, request),
            'url':
            url.set_url_context(site_url +
                                ('/business/%ss/obj-%s' %
                                 (item.type, item.parliamentary_item_id)))
        }

        if include_actions:
            record['actions'] = get_scheduling_actions(scheduling, request)
            record['workflow'] = get_workflow_actions(item, request)

            discussion_actions = get_discussion_actions(discussion, request)
            if discussion_actions:
                assert len(discussion_actions) == 1
                record['discussion_action'] = discussion_actions[0]
            else:
                record['discussion_action'] = None
        items.append(record)
    return items