Пример #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
Пример #2
0
    def dump_csv(self, id):
        dbFacade = self.dbFacade()

        if "all" == id:
            balance_uids = [userBalance.balance_uid for userBalance in h.authenticated_user().balances]
        else:
            c.balance = dbFacade.balances.balanceDao.find_by_uid(id)
            if not c.balance:
                abort(404)

            if not c.balance.can_modify_balance(h.authenticated_user().uid):
                abort(403)
            balance_uids = [c.balance.uid]
        
        charset = request.params.get('charset', 'cp1250')

        changes = dbFacade.db.query(dbFacade.model.BalanceChange) \
            .options(eagerload('change_category'), eagerload('tags')).join(dbFacade.model.BalanceChange.change_category) \
            .filter(or_(*[dbFacade.model.BalanceChange.balance.has(dbFacade.model.Balance.uid == uid) for uid in balance_uids])) \
            .order_by(dbFacade.model.BalanceChange.occurred_on, dbFacade.model.BalanceChange.uid).all()

        response.headers['Content-Type'] = str('text/csv; charset=%s' % charset)
        response.headers['Content-Disposition'] = str("attachment; filename = %s.csv" % self.filename((hasattr(c, 'balance') and c.balance.name or "all")))
        output = StringIO()
        csv = UnicodeWriter(output, encoding=charset)
        csv.writerows([
            [unicode(change.occurred_on), unicode(change.amount), change.change_category.name, change.description, change.tags_as_string() ] for change in changes
        ])
        return output.getvalue()
Пример #3
0
 def get_by_users(self, users):
     user_uids = [user.uid for user in users]
     q = VoteIdeaData.query \
         .filter(VoteIdeaData.user_uid.in_(user_uids)) \
         .options(eagerload(VoteIdeaData.idea),
                  eagerload(VoteIdeaData.user))
     return self._get_by_query(q)
Пример #4
0
    def test_weakref_with_cycles_o2o(self):
        s = sessionmaker()()
        mapper(User, users, properties={
            "address":relation(Address, backref="user", uselist=False)
        })
        mapper(Address, addresses)
        s.add(User(name="ed", address=Address(email_address="ed1")))
        s.commit()

        user = s.query(User).options(eagerload(User.address)).one()
        user.address.user
        eq_(user, User(name="ed", address=Address(email_address="ed1")))

        del user
        gc.collect()
        assert len(s.identity_map) == 0

        user = s.query(User).options(eagerload(User.address)).one()
        user.address.email_address='ed2'
        user.address.user # lazyload

        del user
        gc.collect()
        assert len(s.identity_map) == 2
        
        s.commit()
        user = s.query(User).options(eagerload(User.address)).one()
        eq_(user, User(name="ed", address=Address(email_address="ed2")))
Пример #5
0
 def get_game(cls, game):
     return DBSession.query(cls)\
                     .options(eagerload('player'),
                              eagerload('team'))\
                     .with_polymorphic('*')\
                     .filter(cls.game_id==game.id)\
                     .all()
Пример #6
0
Файл: kb.py Проект: Plurk/Solace
def _topic_feed(request, title, query, order_by):
    # non moderators cannot see deleted posts, so we filter them out first
    # for moderators we mark the posts up as deleted so that
    # they can be kept apart from non-deleted ones.
    if not request.user or not request.user.is_moderator:
        query = query.filter_by(is_deleted=False)
    query = query.order_by(_topic_order[order_by])
    query = query.options(eagerload('author'), eagerload('question'))
    query = query.limit(max(0, min(50, request.args.get('num', 10, type=int))))

    feed = AtomFeed(u'%s — %s' % (title, settings.WEBSITE_TITLE),
                    subtitle=settings.WEBSITE_TAGLINE,
                    feed_url=request.url,
                    url=request.url_root)

    for topic in query.all():
        title = topic.title
        if topic.is_deleted:
            title += u' ' + _(u'(deleted)')
        feed.add(title, topic.question.rendered_text, content_type='html',
                 author=topic.author.display_name,
                 url=url_for(topic, _external=True),
                 id=topic.guid, updated=topic.last_change, published=topic.date)

    return feed.get_response()
Пример #7
0
Файл: basic.py Проект: kuba/SIS
    def schedule(self, schedule_id=None, eager=True):
        """
        Get educator's full week schedule.

        :param schedule_id: Optional schedule's id to work on.
        :type schedule_id: :class:`int`

        :param eager: Whether or not to eagerly load lesson's group
                      and group's year.
        :type eager: :class:`bool`

        """
        q = Lesson.query_current(schedule_id)
        q = q.filter(Lesson.teacher_id == self.id)

        if eager:
            q = q.options(eagerload('group'), eagerload('group.year'))

        days = {}
        for x in range(0,5):
            days[x] = []
        for lesson in q.all():
            days[lesson.day].append(lesson)
        schedule = []
        for day in days.values():
            schedule.append(self._process_schedule(day))
        return schedule
Пример #8
0
Файл: basic.py Проект: kuba/SIS
    def lesson(self, day, order, schedule_id=None, eager=True):
        """
        Get scheduled lesson for given day and order.

        :param day: The day
        :type day: :class:`int`

        :param order: The lesson order
        :type order: :class:`int`

        :param schedule_id: Schedule to work on
        :type schedule_id: :class:`int`

        :param eager: Whether or not eager load lesson's
                      group and group's year.
        :type eager: :class`bool`

        """
        q = Lesson.query_current(schedule_id)
        q = q.filter(Lesson.day == day).\
              filter(Lesson.order == order).\
              filter(Lesson.teacher_id == self.id)

        if eager:
            q = q.options(eagerload('group'), eagerload('group.year'))

        return q.all()
Пример #9
0
 def get_game(cls, game_id):
     return DBSession.query(cls)\
                     .options(eagerload('away_team'),
                              eagerload('home_team'),
                              eagerload('home_scores'),
                              eagerload('away_scores'),
                              eagerload('officials'),)\
                     .get(game_id)
Пример #10
0
 def dnps(cls, game):
     return DBSession.query(cls)\
                     .options(eagerload('player'),
                              eagerload('player.positions'),
                              eagerload('team'),
                              eagerload('team.league'))\
                    .join(GamePlayerDNP)\
                    .filter(cls.game==game)
Пример #11
0
 def current_players(cls, league):
     return DBSession.query(cls)\
                     .join(Person, PersonName)\
                     .options(eagerload('person.height_weight'),
                              eagerload('person.college'))\
                     .join(TeamPlayer)\
                     .filter(TeamPlayer.current==True, 
                             Player.league==league)\
                     .order_by(PersonName.full_name)
Пример #12
0
    def list(self, balance_uid):
        model = request.environ['sqlalchemy.model']
        db = request.environ['sqlalchemy.session']

        balance = db.query(model.Balance).filter_by(uid = balance_uid).first()
        if not balance or not balance.can_see_balance(h.authenticated_user().uid):
            return { "failure": Messages.permissionDenied() }

        qr = balance.changes \
            .options(eagerload('expense_category'), eagerload('income_category'), eagerload('tags')) \
            .order_by(model.BalanceChange.occurred_on)

        (start_date, end_date) = self._get_dates()

        if start_date:
            qr = qr.filter(model.BalanceChange.occurred_on >= start_date)

        if end_date:
            qr = qr.filter(model.BalanceChange.occurred_on <= end_date)

        balance_changes = qr.all()

        total = len(balance_changes)
        try:
            page_nr = int(request.params['page_nr'])
        except:
            page_nr = 1

        try:
            items_per_page = int(request.params['items_per_page'])
        except:
            items_per_page = 15
        
        subset = Page(balance_changes, item_count=total, current_page=page_nr, items_per_page=items_per_page)
        return {
            "summary" : {
                "total" : self._total(balance_uid),
                "date_range" : {
                    "expenses" : self._expenses_for_date_range(balance_uid, start_date, end_date),
                    "incomes" : self._incomes_for_date_range(balance_uid, start_date, end_date),
                },
            },
            "changes": { 
            "totalItems" : total,
            "itemsFound" : len(subset),
            "items" : [{ 
                "uid" : item.uid, 
                "category_uid" : item.is_income and item.income_category_uid or item.expense_category_uid, 
                "category" : (item.is_income and item.income_category or item.expense_category).name, 
                "amount" : Decimal(item.amount), 
                "description" : item.description, 
                "occurred_on": str(item.occurred_on), 
                "is_income": item.is_income,
                "tags_as_string": item.tags_as_string()} for item in subset ]
            }
        }
Пример #13
0
 def rankings(self):
     session = DBSession()
     rankings = session.query(FantasyRanking)\
                       .options(eagerload('rankings'),
                                eagerload('rankings.player'),
                                eagerload('rankings.player.positions'))
     self.data.update({
         'rankings': rankings
     })
     return self.data
Пример #14
0
 def player_stats(cls, sport, league, game_type, player):
     stats = DBSession.query(cls)\
                      .options(eagerload('game'), 
                               eagerload('game.season'))\
                      .with_polymorphic('*')\
                      .join(Game)\
                      .filter(cls.player==player,
                              cls.stat_type!='offense',
                              Game.game_type==game_type)
     return stats
Пример #15
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
Пример #16
0
 def team_schedule(cls, team, game_type, year):
     return DBSession.query(cls)\
                     .options(eagerload('away_team'),
                             eagerload('home_team'),
                             eagerload('home_scores'),
                             eagerload('away_scores'),)\
                     .filter(or_(cls.home_team==team, 
                                cls.away_team==team),
                            cls.game_type==game_type,
                            cls.season.has(year=year))\
                     .order_by(Game.game_time)
Пример #17
0
 def _subcontainer_id_map(self, id_list):
     """Return an id to model map of all subcontainer-type models in the id_list."""
     if not id_list:
         return []
     component_class = self.subcontainer_class
     query = (self._session().query(component_class)
         .filter(component_class.id.in_(id_list))
         .options(eagerload('collection'))
         .options(eagerload('tags'))
         .options(eagerload('annotations')))
     return dict((row.id, row) for row in query.all())
Пример #18
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
Пример #19
0
 def get_date(cls, league, date):
     day = datetime.timedelta(days=1)
     return DBSession.query(cls)\
                    .options(eagerload('home_scores'),
                             eagerload('away_scores'),
                             eagerload('home_team'),
                             eagerload('away_team'),
                             eagerload('league'))\
                    .filter(cls.league==league,
                            cls.game_time.between(date, date+day))\
                    .order_by(cls.game_time)\
                    .all()
Пример #20
0
 def _contained_id_map(self, id_list):
     """Return an id to model map of all contained-type models in the id_list."""
     if not id_list:
         return []
     component_class = self.contained_class
     query = (self._session().query(component_class)
         .filter(component_class.id.in_(id_list))
         .options(undefer('_metadata'))
         .options(eagerload('dataset.actions'))
         .options(eagerload('tags'))
         .options(eagerload('annotations')))
     return dict((row.id, row) for row in query.all())
Пример #21
0
 def get_sittings(self):
     #!+QUERIES(mb, nov-2011) to review the extra queries in `get_items`
     formatter = self.request.locale.dates.getFormatter("date", "full") 
     session = Session()
     query = session.query(domain.GroupSitting).filter(
         self.group_sittings_filter
     ).order_by(schema.group_sittings.c.start_date).options(
         eagerload("group"), 
         #eagerload("sitting_type"),
         eagerload("item_schedule")
     )
     if not self.end_date:
         query = query.limit(
             BungeniSettings(
                 common.get_application()
             ).max_sittings_in_business
         )
     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
Пример #22
0
    def export_to_cdn(self, date_from, date_to):
        """Export invoices to OPTIMA"""
        doc = Document()
        from pytis.model import meta
        buffer = StringIO.StringIO()
        
        invoices = Invoice.query.options(eagerload('elements')).filter(Invoice.issueDate.between(date_from , date_to)).order_by(Invoice.series_number).all()
        corrects = InvoiceCorrect.query.options(eagerload('positions')).filter(InvoiceCorrect.correct_date.between(date_from, date_to)).order_by(InvoiceCorrect.series_number).all()

        root = doc.createElement('ROOT')
        root.setAttribute('xmlns', 'http://www.cdn.com.pl/optima/offline')
        doc.appendChild(root)

        companiesElement = doc.createElement('KONTRAHENCI')
        companiesElement.appendChild(self._add_element(doc, 'WERSJA', '2.00'))
        companiesElement.appendChild(self._add_element(doc, 'BAZA_ZRD_ID', 'SPRZ'))
        companiesElement.appendChild(self._add_element(doc, 'BAZA_DOC_ID', 'SPRZ'))
        root.appendChild(companiesElement)

        companies = []
        for invoice in invoices:
            """fetch sets of companies"""
            if invoice.company not in companies:
                companies.append(invoice.company)

        for correct in corrects:
            """fetch sets of companies"""
            if correct.company not in companies:
                companies.append(correct.company)

        for company in companies:            
            companiesElement.appendChild(self._add_company(doc, company))
        root.appendChild(companiesElement)

        invoicesElement = doc.createElement('REJESTRY_SPRZEDAZY_VAT')
        invoicesElement.appendChild(self._add_element(doc, 'WERSJA', '2.00'))
        invoicesElement.appendChild(self._add_element(doc, 'BAZA_ZRD_ID', 'SPRZ'))
        invoicesElement.appendChild(self._add_element(doc, 'BAZA_DOC_ID', 'SPRZ'))
        for invoice in invoices:
            invoicesElement.appendChild(self._add_invoice(doc, invoice))

            if not invoice.is_exported:
                invoice.mark_as_exported()
        meta.Session.commit()
        
        for correct in corrects:
            invoicesElement.appendChild(self._add_correct(doc, correct))

        root.appendChild(invoicesElement)

        buffer.write(doc.toprettyxml(indent='', newl=''))        
        return buffer
Пример #23
0
    def crops(self, pick=None):
        q = self.query(Image).options(eagerload("develop"), eagerload("exif")).join(Develop).join(Exif)
        if pick is not None:
            q = q.filter(Image.pick == pick)
        q = q.filter(Develop.croppedHeight != None).filter(Develop.croppedWidth != None).filter(Exif.lens != None)

        c = list()
        for g in q.all():
            if g.develop.fileHeight is None:
                continue
            p = (g.develop.croppedHeight + g.develop.croppedWidth) / (g.develop.fileHeight + g.develop.fileWidth)
            c.append((g.exif.lens, Decimal("%0.2f" % (p))))
        return stats(c)
Пример #24
0
 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'),
             eagerload('sitting_type')
             )
     self.query = sittings
Пример #25
0
 def __init__(self, g, columns):
     mappedClass = tables.PokemonForm
     query = g.session.query(mappedClass)
     query = query.join(tables.PokemonForm.pokemon)
     query = query.join(tables.Pokemon.species)
     query = query.options(eagerload('pokemon'))
     query = query.options(eagerload('pokemon.forms'))
     query = query.options(eagerload('pokemon.species'))
     query = query.options(eagerload('pokemon.species.forms'))
     BaseQueryModel.__init__(self, g, mappedClass, query, columns,
             defaultSortClause=DefaultPokemonSortClause())
     self.tableName = 'PokemonForm'
     self._hack_small_icons = False
Пример #26
0
 def check_calendar_tasks(self, conn):
     now = list(time.gmtime())
     tasks = []
     db_type = get_dbtype()
     if db_type == constants.MYSQL:
         tasks = conn.query(TaskCalendar).options(eagerload('task')).filter((TaskCalendar.dow == 0) | TaskCalendar.dow.op('&')(1 << now[6]) > 0).filter((TaskCalendar.month == 0) | TaskCalendar.month.op('&')(1 << now[1]) > 0).filter((TaskCalendar.day == 0) | TaskCalendar.day.op('&')(1 << now[2]) > 0).filter((TaskCalendar.hour == 0) | TaskCalendar.hour.op('&')(1 << now[3]) > 0).filter((TaskCalendar.minute == 0) | TaskCalendar.minute.op('&')(1 << now[4]) > 0)
     if db_type == constants.ORACLE:
         tasks = conn.query(TaskCalendar).options(eagerload('task')).filter((TaskCalendar.dow == 0) | (func.BITAND(TaskCalendar.dow, 1 << now[6]) > 0)).filter((TaskCalendar.month == 0) | (func.BITAND(TaskCalendar.month, 1 << now[1]) > 0)).filter((TaskCalendar.day == 0) | (func.BITAND(TaskCalendar.day, 1 << now[2]) > 0)).filter((TaskCalendar.hour == 0) | (func.BITAND(TaskCalendar.hour, 1 << now[3]) > 0)).filter((TaskCalendar.minute == 0) | (func.BITAND(TaskCalendar.minute, 1 << now[4]) > 0))
     for cal in tasks:
         task = cal.task
         if self.check_prior_execution(conn, task):
             self.submit_async(task)
         else:
             logger.warning('The prior execution of task %s has not completed. Delaying the current execution...' % task.name)
Пример #27
0
 def shots(self):
     session = DBSession()
     page = 'shots'
     team = self.team
     shot_cords = session.query(ShotCoordinates)\
                         .join(Shot)\
                         .options(eagerload('shot.team'),
                                  eagerload('shot.game'),
                                  eagerload('shot.game.home_team'),
                                  eagerload('shot.game.away_team'),
                                  eagerload('shot.shooter'))\
                         .filter(Shot.team==team)\
                         .all()
     json_shots = []
     for shot_cord in shot_cords:
         shot = shot_cord.shot
         game = shot.game
         if game.away_team == team:
             opponent = game.home_team
         elif game.home_team == team:
             opponent = game.away_team
         else:
             print 'home', game.home_team
             print 'away', game.away_team
             print 'player team', team
             raise Exception("team doesn't exist")
         shot_info = {'shot_id': shot.id,
                     'shooter_name': shot.shooter.person.names[0].full_name,
                     'shooter_id': shot.shooter_id,
                     'period': shot.period,
                     'time_of_game': shot.time_of_game.strftime('%H:%M'),
                     'home_score': shot.home_score,
                     'away_score': shot.away_score,
                     'x': shot_cord.x,
                     'y': shot_cord.y,
                     'length': shot_cord.length,
                     'make': shot.make,
                     'shot_type': shot.shot_type,
                     'game_id': game.id,
                     'opponent_name': opponent.name,
                     'opponent_id': opponent.id,
                     }
         json_shots.append(shot_info)
     json_shots = json.dumps(json_shots)
     self.data.update({
         'json_shots': json_shots
     })
     return self.data
Пример #28
0
    def almanacs_kml(self):
        json = request.params.get('extent')
        # We need to make sure we only select almanacs with pages here,
        query = meta.Session.query(Almanac).join(Almanac.pages).distinct()
        # ... and eager-load the pages since the ktml template uses them.
        query = query.options(eagerload(Almanac.pages))

        # Tried also with contains_eager, not sure what the difference is
        # but I only get a fraction of the expected almanacs:
        #query = meta.Session.query(Almanac).join(Almanac.pages).distinct()
        #query = query.options(contains_eager(Almanac.pages))

        # Also tried using a single, second query for the pages.
        # ... NOPE, requires sqlalchemy > 0.6.0 which blows up on us,
        # maybe not compatible w/ pylons 0.9.7?
        #query = meta.Session.query(Almanac).join(Almanac.pages).distinct()
        #query = query.options(subqueryload(Almanac.pages))

        # Tried also without the explicit join().distinct(), this gives
        # back all almanac whether they have any pages or not:
        #query = meta.Session.query(Almanac).options(eagerload(Almanac.pages))

        if json is not None:
            shape = simplejson.loads(json)
            # Stupid asShape returns an Adapter instead of a Geometry.  We round
            # trip it through wkb to get the correct type.
            bbox = wkb.loads(asShape(shape).to_wkb())
            query = query.filter(func.st_intersects(Almanac.location, func.st_transform('SRID=%s;%s' % ('4326', b2a_hex(bbox.to_wkb())), storage_SRID)))

        c.almanacs = query.order_by(Almanac.modified.desc()).limit(200).all()
        response.content_type = 'application/vnd.google-earth.kml+xml kml'
        return render('/almanac/kml.mako')
Пример #29
0
    def delete(self):
        result = {}
        for id in request.params.getall('id'):
            try:
                item = self.dbFacade().balances.changeDao.find_by_uid(id, options=[eagerload('balance'), eagerload('transfer')])
                if item is None:
                    result[id] = {
                        "deleted" : False,
                        "message": Messages.elementNotFound(key=id)
                    }
                    continue

                if not item.balance or not item.balance.can_modify_balance(h.authenticated_user().uid) \
                    or (item.transfer and not item.transfer.balance) \
                    or (item.transfer and not item.transfer.balance.can_modify_balance(h.authenticated_user().uid)):
                    result[id] = {
                        "deleted" : False,
                        "message": Messages.permissionDenied()
                    }
                    continue
                
                if item.transfer:
                    self.dbFacade().db.delete(item.transfer)
                self.dbFacade().db.delete(item)
                self.dbFacade().db.commit()
                result[id] = { "deleted" : True }
            except Exception, e:
                result[id] = {
                    "deleted" : False,
                    "message" : Messages.failedToDelete(exception=e),
                }
Пример #30
0
    def deleted_histories( self, trans, **kwd ):
        """
        The number of histories that were deleted more than the specified number of days ago, but have not yet been purged.
        Also included is the number of datasets associated with the histories.
        """
        params = util.Params( kwd )
        message = ''
        if params.deleted_histories_days:
            deleted_histories_days = int( params.deleted_histories_days )
            cutoff_time = datetime.utcnow() - timedelta( days=deleted_histories_days )
            history_count = 0
            dataset_count = 0
            disk_space = 0
            histories = trans.sa_session.query( model.History ) \
                .filter( and_( model.History.table.c.deleted == true(),
                    model.History.table.c.purged == false(),
                    model.History.table.c.update_time < cutoff_time ) ) \
                .options( eagerload( 'datasets' ) )

            for history in histories:
                for hda in history.datasets:
                    if not hda.dataset.purged:
                        dataset_count += 1
                        try:
                            disk_space += hda.dataset.file_size
                        except:
                            pass
                history_count += 1
            message = "%d histories ( including a total of %d datasets ) were deleted more than %d days ago, but have not yet been purged, " \
                "disk space: %s." % ( history_count, dataset_count, deleted_histories_days, nice_size( disk_space, True ) )
        else:
            message = "Enter the number of days."
        return str( deleted_histories_days ), message
Пример #31
0
 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._setData()
Пример #32
0
 def get_sittings(self, start, end):
     """ return the sittings with scheduled items for 
             the given daterange"""
     session = Session()
     query = session.query(domain.GroupSitting).filter(
         sql.and_(domain.GroupSitting.start_date.between(start, end),
                  domain.GroupSitting.group_id ==
                  self.context.group_id)).order_by(
                      domain.GroupSitting.start_date).options(
                          #eagerload("sitting_type"),
                          eagerload("item_schedule"),
                          eagerload("item_schedule.item"),
                          eagerload("item_schedule.discussion"))
     items = query.all()
     order = "real_order" if self.display_minutes else "planned_order"
     for item in items:
         item.item_schedule.sort(key=operator.attrgetter(order))
         #item.sitting_type.sitting_type = item.sitting_type.sitting_type.capitalize()
     return items
Пример #33
0
 def get_task_details(self, task_ids):
     result = []
     LOGGER.debug("get_task_details query start : " +
                  to_str(datetime.utcnow()))
     task=DBSession.query(Task).filter(Task.task_id.in_(task_ids)).\
                             options(eagerload("result")).all()
     LOGGER.debug("get_task_details query end   : " +
                  to_str(datetime.utcnow()))
     result = self.format_task_details(task)
     return result
Пример #34
0
    def _get_item_as_row(self, item_name):
        q = model.meta.Session.query(model.User)
        q = q.filter(model.User.user_name == unicode(item_name))
        q = q.options(eagerload(model.User.memberships))

        try:
            return q.one()
        except NoResultFound, e:
            log.exception(e)
            raise SourceError("No such user: %s" % item_name)
Пример #35
0
 def actions(self):
     """List of action not in this component"""
     s = model.Session()
     components = s.query(model.Component).options(eagerload("modules")).filter_by(com_status='1').all()
     results = []
     for comp in components:
         for m in comp.modules:
             results.append({'cname': comp.com_name, 'c_id': comp.id, 'mname':m.mod_title, 'm_id': m.id})
     response.headers['content-type'] = 'text/plain'
     return simplejson.dumps({'Resuls': results})
Пример #36
0
    def get_items(self):
        session = Session()
        where_clause = sql.and_(
            schema.group_sittings.c.status.in_(
                get_states("groupsitting",
                           tagged=["public"],
                           not_tagged=["agendaprivate"],
                           conjunction="AND")),
            sql.between(schema.group_sittings.c.start_date, self.start_date,
                        self.end_date))

        query = session.query(domain.ItemSchedule).join(
            domain.GroupSitting).filter(where_clause).order_by(
                schema.group_sittings.c.start_date).options(
                    eagerload('sitting'),
                    eagerload('item'),
                    #eagerload('sitting.sitting_type'),
                    lazyload('item.owner'))
        self.itemschedules = query.all()
Пример #37
0
 def __init__(self, context, request, view, manager):
     super(MemberSpeechesViewlet, self).__init__(
         context, request, view, manager)
     user_id = self.context.user_id
     self.sittings = Session().query(domain.GroupSitting) \
                         .join((domain.Hansard, domain.Hansard.sitting_id == domain.GroupSitting.sitting_id)) \
                         .join((domain.Speech, domain.Speech.hansard_id == domain.Hansard.hansard_id)) \
                         .filter(sql.and_(domain.Speech.person_id == user_id)) \
                         .options( eagerload("group"),
                                   eagerload("hansard"), 
                                   eagerload("hansard.speeches")) \
                         .order_by(domain.Speech.start_date.desc()).all()
     
     for sitting in self.sittings:
         sitting.href = "/business/sittings/obj-%s/hansard" % sitting.sitting_id
         sitting.mp_speeches = []
         for speech in sitting.hansard.speeches:
             if (speech.person_id == user_id):
                 sitting.mp_speeches.append(speech)
Пример #38
0
 def get_groups(user_id):
     principal_ids = []
     session = Session()
     query = session.query(domain.GroupMember).filter(
         rdb.and_(domain.GroupMember.user_id == user_id,
                  domain.GroupMember.active_p == True)).options(
                      eagerload("group"), lazyload("user"))
     for member in query:
         principal_ids.append(member.group.principal_name)
     return principal_ids
Пример #39
0
    def _subcontainer_id_map(self, id_list, serialization_params=None):
        """Return an id to model map of all subcontainer-type models in the id_list."""
        if not id_list:
            return []
        component_class = self.subcontainer_class
        query = (self._session().query(component_class)
            .filter(component_class.id.in_(id_list))
            .options(eagerload('collection'))
            .options(eagerload('tags'))
            .options(eagerload('annotations')))

        # This will conditionally join a potentially costly job_state summary
        # All the paranoia if-checking makes me wonder if serialization_params
        # should really be a property of the manager class instance
        if serialization_params and serialization_params.keys:
            if 'job_state_summary' in serialization_params.keys:
                query = query.options(eagerload('job_state_summary'))

        return {row.id: row for row in query.all()}
Пример #40
0
    def get_wiki(self, wiki=None, attrload=[], attrload_all=[]):
        """Get the Wiki instance identified by,
        `wiki`, which can be,
            `id` or `wikiurl` or `Wiki` instance.

        Return
            List of Wiki instances or
            Wiki instance."""
        msession = meta.Session()

        if isinstance(wiki, Wiki) and attrload == [] and attrload == []:
            return wiki

        # Compose query based on `wiki` type
        if isinstance(wiki, (int, long)):
            q = msession.query(Wiki).filter_by(id=wiki)

        elif isinstance(wiki, (str, unicode)):
            q = msession.query(Wiki).filter_by(wikiurl=wiki)

        elif isinstance(wiki, Wiki):
            q = msession.query(Wiki).filter_by(id=wiki.id)

        else:
            q = None

        # Compose eager-loading options
        if q != None:
            q = q.options(*[eagerload_all(e) for e in attrload_all])
            q = q.options(*[eagerload(e) for e in attrload])
            wiki = q.first()

        elif wiki == None:
            q = msession.query(Wiki)
            q = q.options(*[eagerload_all(e) for e in attrload_all])
            q = q.options(*[eagerload(e) for e in attrload])
            wiki = q.all()

        else:
            wiki = None

        return wiki
Пример #41
0
def all(team_id=0):  # show all matches
    team = None
    if team_id:
        if not g.user.is_on_team(team_id):
            team = Team.query.filter_by(id=team_id).first()

            if not team:
                return redirect(url_for('all'))

            page = {'top': 'team', 'sub': 'matches'}
        else:
            team = {'id': team_id, 'name': g.user.teams[team_id].name}
            page = {'top': 'my_teams', 'sub': 'matches'}

        matches=Match.query.\
                options(eagerload('competition')).\
                filter_by(team_id=team_id).\
                order_by(Match.date.asc()).\
                order_by(Match.id.asc()).\
                all()
    else:
        matches=Match.query.\
                options(eagerload('competition')).\
                order_by(Match.date.asc()).\
                order_by(Match.id.asc()).\
                all()
        page = {'top': 'matches', 'sub': 'all_matches'}

    now = datetime.datetime.utcnow()
    upcoming = []
    previous = []
    for m in matches:
        if m.date > now:
            upcoming.append(m)
        else:
            previous.append(m)

    return rt('matches/table.html',
              page=page,
              team=team,
              upcoming=upcoming,
              previous=previous)
Пример #42
0
def package(pkg):
    db = current_app.config['DB']()
    collections = list(queries.collections(db))

    query = db.query(tables.Package)
    query = query.options(eagerload('status_obj'))
    query = query.options(subqueryload('collection_packages'))
    query = query.options(subqueryload('collection_packages.links'))
    query = query.options(eagerload('collection_packages.status_obj'))
    query = query.options(subqueryload('collection_packages.rpms'))
    query = query.options(
        eagerload('collection_packages.rpms.py_dependencies'))
    package = query.get(pkg)
    if package is None:
        abort(404)

    query = queries.dependencies(db, package)
    query = query.options(eagerload('status_obj'))
    query = query.options(subqueryload('collection_packages'))
    query = query.options(subqueryload('collection_packages.links'))
    query = query.options(eagerload('collection_packages.status_obj'))
    dependencies = list(query)

    dependents = list(queries.dependents(db, package))

    in_progress_deps = [p for p in dependencies if p.status == 'in-progress']

    return render_template(
        'package.html',
        breadcrumbs=(
            (url_for('hello'), 'Python 3 Porting Database'),
            (url_for('package', pkg=pkg), pkg),
        ),
        collections=collections,
        pkg=package,
        dependencies=dependencies,
        dependents=dependents,
        deptree=[(package, gen_deptree(dependencies))],
        in_progress_deps=in_progress_deps,
        len_dependencies=len(dependencies),
        dependencies_status_counts=get_status_counts(dependencies),
    )
Пример #43
0
def get_log(session, dag_id, dag_run_id, task_id, task_try_number, full_content=False, token=None):
    """Get logs for specific task instance"""
    key = current_app.config["SECRET_KEY"]
    if not token:
        metadata = {}
    else:
        try:
            metadata = URLSafeSerializer(key).loads(token)
        except BadSignature:
            raise BadRequest("Bad Signature. Please use only the tokens provided by the API.")

    if metadata.get('download_logs') and metadata['download_logs']:
        full_content = True

    if full_content:
        metadata['download_logs'] = True
    else:
        metadata['download_logs'] = False

    task_log_reader = TaskLogReader()
    if not task_log_reader.supports_read:
        raise BadRequest("Task log handler does not support read logs.")

    ti = (
        session.query(TaskInstance)
        .filter(TaskInstance.task_id == task_id, TaskInstance.run_id == dag_run_id)
        .join(TaskInstance.dag_run)
        .options(eagerload(TaskInstance.dag_run))
        .one_or_none()
    )
    if ti is None:
        metadata['end_of_log'] = True
        raise NotFound(title="TaskInstance not found")

    dag = current_app.dag_bag.get_dag(dag_id)
    if dag:
        try:
            ti.task = dag.get_task(ti.task_id)
        except TaskNotFound:
            pass

    return_type = request.accept_mimetypes.best_match(['text/plain', 'application/json'])

    # return_type would be either the above two or None

    if return_type == 'application/json' or return_type is None:  # default
        logs, metadata = task_log_reader.read_log_chunks(ti, task_try_number, metadata)
        logs = logs[0] if task_try_number is not None else logs
        token = URLSafeSerializer(key).dumps(metadata)
        return logs_schema.dump(LogResponseObject(continuation_token=token, content=logs))
    # text/plain. Stream
    logs = task_log_reader.read_log_stream(ti, task_try_number, metadata)

    return Response(logs, headers={"Content-Type": return_type})
Пример #44
0
 def getBom(self, itemId):
     item = self.sess.query(Item).options(eagerload('boms')).get(itemId)
     return [{
         'pkey': '%d%d' % (sku.itemId, sku.componentItemId),
         'itemId': sku.componentItemId,
         'itemName': sku.item.itemName,
         'specification': sku.item.specification,
         'model': sku.item.model,
         'weight': sku.item.weight,
         'quantity': sku.quantity
     } for sku in item.boms]
Пример #45
0
 def find(cls, id, instance_filter=True, include_deleted=False, full=False):
     try:
         q = meta.Session.query(Proposal)
         id = int(unicode(id).split('-', 1)[0])
         q = q.filter(Proposal.id == id)
         if full:
             q = q.options(eagerload(Proposal.comments))
             q = q.options(eagerload(Proposal.adopt_poll))
             q = q.options(eagerload(Proposal.rate_poll))
             q = q.options(eagerload(Proposal.taggings))
             q = q.options(eagerload(Proposal.parents))
         if ifilter.has_instance() and instance_filter:
             q = q.filter(Proposal.instance_id == ifilter.get_instance().id)
         if not include_deleted:
             q = q.filter(or_(Proposal.delete_time == None,  # noqa
                              Proposal.delete_time > datetime.utcnow()))
         return q.limit(1).first()
     except Exception, e:
         log.warn("find(%s): %s" % (id, e))
         return None
Пример #46
0
    def find_methods(self, search_string, stage=None, limit=100):
        """Find all methods that match the search string"""
        with closing(self.database.session()) as session:
            wildcard_search_string = search_string.replace(' ', '%')
            q = session.query(models.Method).filter(models.Method.name.ilike(f'%{wildcard_search_string}%'))
            if stage:
                q = q.filter(models.Method.stage == stage)
            if limit:
                q = q.limit(limit)

            return q.options(eagerload('*')).all()
Пример #47
0
    def index(self, page=1, search=None, media_filter=None, **kwargs):
        """List comments with pagination and filtering.

        :param page: Page number, defaults to 1.
        :type page: int
        :param search: Optional search term to filter by
        :type search: unicode or None
        :param media_filter: Optional media ID to filter by
        :type media_filter: int or None
        :rtype: dict
        :returns:
            comments
                The list of :class:`~mediadrop.model.comments.Comment` instances
                for this page.
            edit_form
                The :class:`mediadrop.forms.admin.comments.EditCommentForm` instance,
                to be rendered for each instance in ``comments``.
            search
                The given search term, if any
            search_form
                The :class:`~mediadrop.forms.admin.SearchForm` instance
            media_filter
                The given podcast ID to filter by, if any
            media_filter_title
                The media title for rendering if a ``media_filter`` was specified.

        """
        comments = Comment.query.trash(False)\
            .order_by(Comment.reviewed.asc(),
                      Comment.created_on.desc())

        # This only works since we only have comments on one type of content.
        # It will need re-evaluation if we ever add others.
        comments = comments.options(orm.eagerload('media'))

        if search is not None:
            comments = comments.search(search)

        media_filter_title = media_filter
        if media_filter is not None:
            comments = comments.filter(
                Comment.media.has(Media.id == media_filter))
            media_filter_title = DBSession.query(Media.title).get(media_filter)
            media_filter = int(media_filter)

        return dict(
            comments=comments,
            edit_form=edit_form,
            media_filter=media_filter,
            media_filter_title=media_filter_title,
            search=search,
            search_form=search_form,
        )
Пример #48
0
def my_previous_matches():
    if g.user.is_guest:
        return redirect(url_for('all'))

    cutoff = datetime.datetime.utcnow()
    matches = Match.query.\
            filter(Match.team_id.in_(g.user.teams.keys())).\
            filter(Match.date <= cutoff).\
            options(eagerload('competition'), \
                    eagerload('server')).\
            order_by(Match.date.asc()).\
            order_by(Match.id.asc()).\
            all()

    return rt('matches/table.html',
              page={
                  'top': 'my_matches',
                  'sub': 'previous'
              },
              previous_only=True,
              previous=matches)
Пример #49
0
 def by_subjects(cls, subjects, include_deleted=True):
     try:
         q = meta.Session.query(Poll)
         q = q.filter(Poll.subject.in_(subjects))
         q = q.options(eagerload(Poll.tallies))
         if not include_deleted:
             q = q.filter(or_(Poll.end_time == None,  # noqa
                              Poll.end_time > datetime.utcnow()))
         return q.all()
     except Exception, e:
         log.exception("by_subjects(%s): %s" % (subjects, e), e)
         return []
Пример #50
0
def processEager(eager):
    if eager == None:
        return tuple()
    else:
        l = []
        if isinstance(eager, basestring):
            eager = (eager, )

        for e in eager:
            l.append(eagerload(_replacements(e)))

        return l
Пример #51
0
    def get_bills(self, **kwargs):
        """
        Returns a list of all bills filtered by values.
        """
        records = []

        try:
            session = self.dal.Session()
            records = session.query(Bill).options(
                eagerload('category')).filter_by(**kwargs).all()
        except Exception, e:
            print str(e)
Пример #52
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('sitting_type'),
        eagerload('item_schedule')).get(s.sitting_id)
    schedulings = map(removeSecurityProxy, sitting.item_schedule)
    if sitting.status == "draft_agenda":
        for sch in schedulings:
            if sch.item.type != "heading":
                wf_info = IWorkflowInfo(sch.item)
                transitions = wf_info.getSystemTransitionIds()
                state = wf_info.state()
                wf = wf_info.workflow()
                next_state = get_states(sch.item.type,
                                        tagged=["tobescheduled"])
                for transition_id in transitions:
                    t = wf.getTransition(state.getState(), transition_id)
                    if t.destination in next_state:
                        #TODO find out why firetransition fails for reschedule even
                        #when the user has requisite permissions
                        wf_info.fireTransition(transition_id,
                                               check_security=False)
                        break

    elif sitting.status == "published_agenda":
        for sch in schedulings:
            if sch.item.type != "heading":
                wf_info = IWorkflowInfo(sch.item)
                transitions = wf_info.getSystemTransitionIds()
                state = wf_info.state()
                wf = wf_info.workflow()
                next_state = get_states(sch.item.type, tagged=["scheduled"])
                for transition_id in transitions:
                    t = wf.getTransition(state.getState(), transition_id)
                    if t.destination in next_state:
                        wf_info.fireTransition(transition_id,
                                               check_security=False)
                        break
Пример #53
0
def purge_histories( app, cutoff_time, remove_from_disk, info_only=False, force_retry=False ):
    # Purges deleted histories whose update_time is older than the cutoff_time.
    # The dataset associations of each history are also marked as deleted.
    # The Purge Dataset method will purge each Dataset as necessary
    # history.purged == True simply means that it can no longer be undeleted
    # i.e. all associated datasets are marked as deleted
    history_count = 0
    start = time.time()
    if force_retry:
        histories = app.sa_session.query( app.model.History ) \
                                  .filter( and_( app.model.History.table.c.deleted == true(),
                                                 app.model.History.table.c.update_time < cutoff_time ) ) \
                                  .options( eagerload( 'datasets' ) )
    else:
        histories = app.sa_session.query( app.model.History ) \
                                  .filter( and_( app.model.History.table.c.deleted == true(),
                                                 app.model.History.table.c.purged == false(),
                                                 app.model.History.table.c.update_time < cutoff_time ) ) \
                                  .options( eagerload( 'datasets' ) )
    for history in histories:
        print ("### Processing history id %d (%s)" % (history.id, history.name)).encode('utf-8')
        for dataset_assoc in history.datasets:
            _purge_dataset_instance( dataset_assoc, app, remove_from_disk, info_only=info_only )  # mark a DatasetInstance as deleted, clear associated files, and mark the Dataset as deleted if it is deletable
        if not info_only:
            # TODO: should the Delete DefaultHistoryPermissions be deleted here?  This was incorrectly
            # done in the _list_delete() method of the history controller, so copied it here.  Not sure
            # if we should ever delete info like this from the db though, so commented out for now...
            # for dhp in history.default_permissions:
            #     dhp.delete()
            print "Purging history id ", history.id
            history.purged = True
            app.sa_session.add( history )
            app.sa_session.flush()
        else:
            print "History id %d will be purged (without 'info_only' mode)" % history.id
        history_count += 1
    stop = time.time()
    print 'Purged %d histories.' % history_count
    print "Elapsed time: ", stop - start
    print "##########################################"
Пример #54
0
    def get_wikicomment(self, wikicomment=None, attrload=[], attrload_all=[]):
        """Get the wiki comment identified by,
        `wikicomment` which can be,
            `id` or `WikiComment` instance.
        if wikicomment==None,
            return all the comments for `wiki`.

        Return,
            List of WikiComment instances or
            WikiComment instance."""
        if isinstance( wikicomment, WikiComment ) and attrload==[] and \
           attrload_all==[] :
            wikicmt = wikicomment

        msession = meta.Session()

        # Compose query based on `wikicmt` type
        if isinstance(wikicomment, (int, long)):
            q = msession.query(WikiComment).filter_by(id=wikicomment)
        elif isinstance(wikicomment, WikiComment):
            q = msession.query(WikiComment).filter_by(id=wikicomment.id)
        else:
            q = None

        # Compose eager-loading options
        if q != None:
            q = q.options(*[eagerload_all(e) for e in attrload_all])
            q = q.options(*[eagerload(e) for e in attrload])
            wikicmt = q.first()

        elif wikicomment == None:
            q = msession.query(WikiComment)
            q = q.options(*[eagerload_all(e) for e in attrload_all])
            q = q.options(*[eagerload(e) for e in attrload])
            wikicmt = q.all()

        else:
            wikicmt = None

        return wikicmt
Пример #55
0
    def index(self, page=1, search=None, type=None, **kwargs):
        """List comments with pagination and filtering.

        :param page: Page number, defaults to 1.
        :type page: int
        :param search: Optional search term to filter by
        :type search: unicode or None
        :param media_filter: Optional media ID to filter by
        :type media_filter: int or None
        :rtype: dict
        :returns:
            comments
                The list of :class:`~mediadrop.model.comments.Comment` instances
                for this page.
            edit_form
                The :class:`mediadrop.forms.admin.comments.EditCommentForm` instance,
                to be rendered for each instance in ``comments``.
            search
                The given search term, if any
            search_form
                The :class:`~mediadrop.forms.admin.SearchForm` instance
            media_filter
                The given podcast ID to filter by, if any
            media_filter_title
                The media title for rendering if a ``media_filter`` was specified.

        """
        comments = Comment.query.trash(False)\
            .order_by(Comment.reviewed.asc(),
                      Comment.created_on.desc())
        user = request.perm.user.display_name
        group = request.perm.user.groups[0].group_name

        # This only works since we only have comments on one type of content.
        # It will need re-evaluation if we ever add others.
        comments = comments.options(orm.eagerload('media'))

        if search is not None:
            comments = comments.search(search)

        # If we do implement a search by podcast on the comments do it using those variables.
        media_filter_title = None
        media_filter = None

        return dict(
            comments=comments,
            edit_form=edit_form,
            media_filter=media_filter,
            media_filter_title=media_filter_title,
            search=search,
            search_form=search_form,
        )
Пример #56
0
 def get(self, teamId, projectId, todolistId, todoitemId):
     project = Project.query.filter_by(id=projectId).first()
     todolist = TodoList.query.filter_by(id=todolistId).first()
     todoItem = TodoItem.query.filter_by(id=todoitemId).first()
     operations = Operation.query.options(eagerload('own')).filter_by(
         team_id=teamId, target_type=4,
         target_id=todoitemId).order_by(Operation.createTime).all()
     self.render("operation/todoitem.html",
                 teamId=teamId,
                 todolist=todolist,
                 project=project,
                 todoItem=todoItem,
                 operations=operations)
Пример #57
0
    def lesson(self, day, order, schedule_id=None, eager=True):
        """
        Get scheduled lesson for specified day and order.

        :param schedule_id: Optional schedule's id to work on.
        :type schedule_id: :class:`int`

        :param eager: Whether or not to load eagerly lesson's group
                      and group's year.

        """
        q = Lesson.query_current(schedule_id)
        q = q.join((Group, Lesson.group_id == Group.id)).\
              join((GroupMembership, Group.id == GroupMembership.group_id)).\
              filter(GroupMembership.student_id == self.id).\
              filter(GroupMembership.active == True).\
              filter(Lesson.day == day).\
              filter(Lesson.order == order)

        if eager:
            q = q.options(eagerload('group'), eagerload('group.year'))
        return q.all()
Пример #58
0
    def get_sittings(self):
        session = Session()
        logged_in_user = get_db_user()
        title = get_title_of_user(logged_in_user.user_id)

        sittings = session.query(domain.GroupSitting).join((domain.Assignment,
                                    domain.GroupSitting.sitting_id
                                             == domain.Assignment.sitting_id)) \
                .filter(sql.and_(domain.GroupSitting.status == 'draft_minutes',
                        domain.Assignment.staff_id == logged_in_user.user_id)) \
                .options( eagerload("hansard"),
                            eagerload("hansard.media_paths")).all()
        for sitting in sittings:
            if title == "Editor":
                takes = session.query(domain.Take)\
                    .filter(sql.and_(domain.Take.editor_id == logged_in_user.user_id,
                    domain.Take.sitting_id == sitting.sitting_id)) \
                    .order_by(domain.Take.start_date).all()
            elif title == "Reader":
                takes = session.query(domain.Take)\
                    .filter(sql.and_(domain.Take.reader_id == logged_in_user.user_id,
                    domain.Take.sitting_id == sitting.sitting_id)) \
                    .order_by(domain.Take.start_date).all()
            elif title == "Reporter":
                takes = session.query(domain.Take)\
                    .filter(sql.and_(domain.Take.reporter_id == logged_in_user.user_id,
                    domain.Take.sitting_id == sitting.sitting_id)) \
                    .order_by(domain.Take.start_date).all()
            for take in takes:
                take.start_time = take.start_date - sitting.start_date
                take.end_time = take.end_date - sitting.start_date
            sitting.takes = takes
            if sitting.hansard.media_paths:
                sitting.file = sitting.hansard.media_paths.web_optimised_video_path
            else:
                sitting.file = ""
            sitting.name = sitting.group.short_name + str(
                sitting.start_date.strftime('%d-%B-%Y %H:%M'))
        return sittings
Пример #59
0
 def reload(self):
     """
     Load all votes by the user regarding the poll.
     """
     q = model.meta.Session.query(Vote)
     q = q.filter(Vote.user_id == self.user.id)
     q = q.filter(Vote.poll_id == self.poll.id)
     q = q.options(eagerload(Vote.delegation))
     if self.at_time:
         q = q.filter(Vote.create_time <= self.at_time)
     q = q.order_by(Vote.id.desc())
     self.votes = q.all()
     return self
Пример #60
0
def package(pkg):
    db = current_app.config['DB']()
    collections = list(queries.collections(db))

    query = db.query(tables.Package)
    query = query.options(eagerload('status_obj'))
    query = query.options(subqueryload('collection_packages'))
    query = query.options(subqueryload('collection_packages.links'))
    query = query.options(eagerload('collection_packages.status_obj'))
    query = query.options(subqueryload('collection_packages.rpms'))
    query = query.options(
        eagerload('collection_packages.rpms.py_dependencies'))
    package = query.get(pkg)
    if package is None:
        abort(404)

    query = queries.dependencies(db, package)
    query = query.options(eagerload('status_obj'))
    query = query.options(subqueryload('collection_packages'))
    query = query.options(subqueryload('collection_packages.links'))
    query = query.options(eagerload('collection_packages.status_obj'))
    dependencies = list(query)

    dependents = list(queries.dependents(db, package))

    query = queries.build_dependencies(db, package)
    query = query.options(eagerload('status_obj'))
    query = query.options(subqueryload('collection_packages'))
    query = query.options(subqueryload('collection_packages.links'))
    query = query.options(eagerload('collection_packages.status_obj'))
    build_dependencies = list(query)

    build_dependents = list(queries.build_dependents(db, package))

    return render_template(
        'package.html',
        breadcrumbs=(
            (url_for('hello'), 'Python 3 Porting Database'),
            (url_for('package', pkg=pkg), pkg),
        ),
        collections=collections,
        pkg=package,
        dependencies=dependencies,
        dependents=dependents,
        deptree=[(package, gen_deptree(dependencies))],
        dependencies_status_counts=get_status_counts(dependencies),
        build_dependencies=build_dependencies,
        build_dependents=build_dependents,
        build_deptree=[(package,
                        gen_deptree(build_dependencies,
                                    run_time=False,
                                    build_time=True))],
        build_dependencies_status_counts=get_status_counts(build_dependencies),
    )