def getSurseSince(user: User, site, since) -> Iterable[Problema]: if site == "all": result = [] if user is None: return Problema.query.filter(Problema.data >= since)\ .options(raiseload('*'))\ .order_by(Problema.data).all() for i in SITES: if user[i] is not None: result += Problema.query.filter(Problema.username == user[i])\ .filter(Problema.sursa == i)\ .filter(Problema.data >= since)\ .options(raiseload('*'))\ .order_by(Problema.data).all() return result else: if user is None: return Problema.query.filter(Problema.data >= since)\ .filter(Problema.sursa == site)\ .options(raiseload('*'))\ .order_by(Problema.data).all() return Problema.query.filter(Problema.username == user[site])\ .options(raiseload('*'))\ .filter(Problema.data >= since)\ .filter(Problema.sursa == site)\ .order_by(Problema.data).all()
def tournament_close(tournament_id): if current_user(): try: tourn = Tournament.query.get(tournament_id) coach = Coach.query.options(raiseload(Coach.cards),raiseload(Coach.packs)).filter_by(disc_id=current_user()['id']).one_or_none() if not coach: raise InvalidUsage("Coach not found", status_code=403) if not coach.web_admin: raise InvalidUsage("Coach does not have webadmin role", status_code=403) #prizes for prize in request.get_json(): tmp_coach = Coach.query.options(raiseload(Coach.cards),raiseload(Coach.packs)).get(prize['coach']) reason = prize['reason']+" by "+coach.short_name() TransactionService.process(tmp_coach,int(prize['amount'])*-1,reason) for coach in tourn.coaches: TournamentService.unregister(tourn,coach,admin=True,refund=False) tourn.phase="deck_building" db.session.commit() result = tournament_schema.dump(tourn) return jsonify(result.data) except (RegistrationError,TransactionError) as e: raise InvalidUsage(str(e), status_code=403) else: raise InvalidUsage('You are not authenticated', status_code=401)
def get_latest_messages(mobile_id, messages_per_convo=20): """ """ query_start = datetime.now() siu = SmsInboxUsers siut = SmsInboxUserTags sms_inbox = DB.session.query( siu.inbox_id.label("convo_id"), siu.inbox_id, bindparam("outbox_id", None), siu.mobile_id, siu.sms_msg, siu.ts_sms.label("ts"), siu.ts_sms.label("ts_received"), bindparam("ts_written", None), bindparam("ts_sent", None), literal("inbox").label("source"), bindparam("send_status", None) ).options(raiseload("*")).filter(siu.mobile_id == mobile_id).order_by(DB.desc(siu.ts_sms)) sou = SmsOutboxUsers sous = SmsOutboxUserStatus sout = SmsOutboxUserTags outbox_sub = sout.query.join(sou).filter( sout.outbox_id == sou.outbox_id).subquery() sms_outbox = DB.session.query( sous.stat_id.label("convo_id"), bindparam("inbox_id", None), sous.outbox_id, sous.mobile_id, sou.sms_msg, sou.ts_written.label("ts"), bindparam("ts_received", None), sou.ts_written, sous.ts_sent, literal("outbox").label("source"), sous.send_status ).options(raiseload("*")).join(sou).filter(sous.mobile_id == mobile_id) \ .order_by(DB.desc(sous.outbox_id)) union = sms_inbox.union(sms_outbox).order_by( DB.desc(text("anon_1_ts"))).limit(messages_per_convo) query_end = datetime.now() print("") print("SCRIPT RUNTIME: GET LATEST MESSAGES", (query_end - query_start).total_seconds()) print("") return union
def query_subcontributions(ids=None): contrib_event = db.aliased(Event) contrib_session = db.aliased(Session) contrib_block = db.aliased(SessionBlock) contrib_strategy = contains_eager(SubContribution.contribution) contrib_strategy.joinedload(Contribution.own_venue) contrib_strategy.joinedload(Contribution.own_room).options( raiseload('*'), joinedload('location')) contrib_strategy.joinedload(Contribution.timetable_entry) apply_acl_entry_strategy( contrib_strategy.selectinload(Contribution.acl_entries), ContributionPrincipal) event_strategy = contrib_strategy.contains_eager( Contribution.event.of_type(contrib_event)) event_strategy.joinedload(contrib_event.own_venue) event_strategy.joinedload(contrib_event.own_room).options( raiseload('*'), joinedload('location')) apply_acl_entry_strategy( event_strategy.selectinload(contrib_event.acl_entries), EventPrincipal) session_strategy = contrib_strategy.contains_eager( Contribution.session.of_type(contrib_session)) apply_acl_entry_strategy( session_strategy.selectinload(contrib_session.acl_entries), SessionPrincipal) session_strategy.joinedload(contrib_session.own_venue) session_strategy.joinedload(contrib_session.own_room).options( raiseload('*'), joinedload('location')) session_block_strategy = contrib_strategy.contains_eager( Contribution.session_block.of_type(contrib_block)) session_block_strategy.joinedload(contrib_block.own_venue) session_block_strategy.joinedload(contrib_block.own_room).options( raiseload('*'), joinedload('location')) if ids is None: export_filter = db.and_(~SubContribution.is_deleted, ~Contribution.is_deleted, ~contrib_event.is_deleted, _get_excluded_category_filter(contrib_event)) else: export_filter = SubContribution.id.in_(ids) return (SubContribution.query.join(Contribution).join( Contribution.event.of_type(contrib_event)).outerjoin( Contribution.session.of_type(contrib_session)).outerjoin( Contribution.session_block.of_type(contrib_block)). filter(export_filter).options( selectinload(SubContribution.person_links).joinedload( 'person').joinedload('user').load_only('is_system'), contrib_strategy, event_strategy, session_strategy, session_block_strategy).order_by(SubContribution.id))
def tournaments_update(): if current_user(): try: coach = Coach.query.options(raiseload(Coach.cards),raiseload(Coach.packs)).filter_by(disc_id=current_user()['id']).one_or_none() if not coach: raise InvalidUsage("Coach not found", status_code=403) if not coach.web_admin: raise InvalidUsage("Coach does not have webadmin role", status_code=403) TournamentService.update() return jsonify(True) except RegistrationError as e: raise InvalidUsage(str(e), status_code=403) else: raise InvalidUsage('You are not authenticated', status_code=401)
def tournament_sign(tournament_id): if current_user(): try: tourn = Tournament.query.get(tournament_id) coach = Coach.query.options(raiseload(Coach.cards),raiseload(Coach.packs)).filter_by(disc_id=current_user()['id']).one_or_none() if not coach: raise InvalidUsage("Coach not found", status_code=403) TournamentService.register(tourn,coach) result = tournament_schema.dump(tourn) return jsonify(result.data) except RegistrationError as e: raise InvalidUsage(str(e), status_code=403) else: raise InvalidUsage('You are not authenticated', status_code=401)
def migrate_user_mobile(): config_name = os.getenv("FLASK_CONFIG") create_app(config_name, skip_memcache=True, skip_websocket=True) numbers = OldUserMobiles.query.options(joinedload( OldUserMobiles.user), raiseload("*")).all() mobile_id_list = [] for num in numbers: mobile_id = num.mobile_id if mobile_id not in mobile_id_list: mobile_id_list.append(mobile_id) new_num = MobileNumbers( mobile_id=mobile_id, sim_num=num.sim_num, gsm_id=num.gsm_id ) DB.session.add(new_num) DB.session.flush() if "UNKNOWN" not in num.user.first_name: new_row_um = UserMobiles( user_id=num.user_id, mobile_id=mobile_id, priority=num.priority, status=num.mobile_status ) DB.session.add(new_row_um)
def get_gundem(gundem_id): """Belirli bir toplanti gundemini almak icin kullaniriz""" user_id = current_user.id try: gundem = DB.session.query(BapGundem).options( joinedload(BapGundem.proje).load_only("proje_basligi", "proje_no", "id").lazyload( "*"), raiseload("*") ).filter_by(id=gundem_id).one() except NoResultFound as exc: CustomErrorHandler.error_handler( hata="Var olmayan bir gundeme ulasilmalay calisildi. User id: {}, " "Gundem id: {}, Hata: {}".format(user_id, gundem_id, exc)) return abort(404) gundem_data = { "gundemId": gundem_id, "sablonId": gundem.sablon_id, "ekDosyaId": gundem.ek_dosya_id, "karar": gundem.karar, "aciklama": gundem.aciklama, "tipi": gundem.tipi.name, "kararDurumu": gundem.karar_durum.name, "gundemSiraNo": gundem.gundem_sira_no, "yonetimeBilgiNotu": gundem.yonetime_bilgi_notu, "kisiyeOzelNot": gundem.kisiye_ozel_not, "projeBasligi": gundem.proje.proje_basligi, "projeId": gundem.proje_id, "projeNo": gundem.proje.proje_no } return jsonify(status="success", gundemData=gundem_data)
def wrap_write_monitoring_moms_to_db(internal_json=None): """ Handles moms. Make sure you pass lists to this function """ try: if internal_json: json_data = internal_json else: json_data = request.get_json() var_checker("json_data", json_data, True) site_code = json_data["site_code"] site_id = DB.session.query(Sites).options( raiseload("*")).filter_by(site_code=site_code).first().site_id var_checker("site_id", site_id, True) moms_list = json_data["moms_list"] for moms_obs in moms_list: write_monitoring_moms_to_db(moms_details=moms_obs, site_id=site_id) DB.session.commit() except Exception as err: print("YOWO", err) DB.session.rollback() return jsonify({"status": False, "message": err}) return jsonify({"status": True, "message": "success"})
def get_suppliers_by_name_keyword(self, keyword, framework_slug=None, category=None, exclude=None, exclude_recruiters=False): query = (db.session.query(Supplier).filter( Supplier.name.ilike('%{}%'.format( keyword.encode('utf-8')))).filter( Supplier.status != 'deleted').options( joinedload(Supplier.frameworks), joinedload(Supplier.domains), joinedload(Supplier.prices), joinedload('domains.domain'), joinedload('prices.service_role'), joinedload('frameworks.framework'), noload('frameworks.framework.lots'), raiseload('*'))) if framework_slug: query = query.outerjoin(SupplierFramework).outerjoin(Framework) query = query.filter(Framework.slug == framework_slug) if category: query = query.outerjoin(SupplierDomain) query = query.filter(SupplierDomain.domain_id == category).filter( SupplierDomain.status == 'assessed') if exclude: query = query.filter(Supplier.code.notin_(exclude)) if exclude_recruiters: query = query.filter(Supplier.data['recruiter'].astext != 'yes') query.order_by(Supplier.name.asc()).limit(20) return query.all()
def search_events(self, q, user, page, category_id, admin_override_enabled): filters = [Event.title_matches(q), ~Event.is_deleted] if category_id is not None: filters.append(Event.category_chain_overlaps(category_id)) query = (Event.query.filter(*filters).options( load_only('id', 'category_id', 'access_key', 'protection_mode'), undefer(Event.effective_protection_mode), _apply_acl_entry_strategy(selectinload(Event.acl_entries), EventPrincipal))) objs, pagenav = self._paginate(query, page, Event.id, user, admin_override_enabled) query = (Event.query.filter(Event.id.in_(e.id for e in objs)).options( undefer(Event.detailed_category_chain), selectinload(Event.person_links).joinedload('person').joinedload( 'user').load_only('is_system'), joinedload(Event.own_venue), joinedload(Event.own_room).options(raiseload('*'), joinedload('location')), )) events_by_id = {e.id: e for e in query} events = [events_by_id[e.id] for e in objs] res = HTMLStrippingEventSchema(many=True).dump(events) return pagenav, EventResultSchema(many=True).load(res)
def toplanti_gundem_listele(toplanti_id): """Toplanti gundemlerini listeler""" user_id = current_user.id gundem_form = ToplantiGundem() try: toplanti = DB.session.query(BapToplanti).options( joinedload(BapToplanti.gundemler).joinedload( BapGundem.proje).load_only("id", "proje_no", "proje_basligi").lazyload("*"), raiseload("*") ).filter_by(id=toplanti_id).one() except NoResultFound as exc: DB.session.rollback() CustomErrorHandler.error_handler( hata="Var olmayan bir toplanti id ile istek gönderildi.User id: {}," " Hata: {}".format(user_id, exc)) return abort(404) gundem_sayisi = len(toplanti.gundemler) gundem_form.gundem_sira_no.choices = [(i + 1, str(i + 1)) for i in range(gundem_sayisi)] # sablon tipi id '51' Yönetim Kurulu Tutanak Şablonunu temsil etmektedir. toplanti_tutanak_sablonu = DB.session.query(Sablon.id.label("sablon_id"), Sablon.sablon_tipi_id.label("sablon_tipi_id")).filter( Sablon.sablon_tipi_id == 51).order_by(desc(Sablon.updated_at)).first() return render_template('toplanti_gundemleri.html', gundemler=toplanti.gundemler, gundem_form=gundem_form, toplanti_id=toplanti_id, toplanti_sonuclandi_mi=toplanti.sonuclandi_mi, toplanti_tutanak_sablon_id=toplanti_tutanak_sablonu.sablon_id, sablon_type_id=toplanti_tutanak_sablonu.sablon_tipi_id)
def current_coach_with_inactive(): """Returns current coach or None""" if current_user(): return Coach.query.with_deleted().options(raiseload( Coach.packs)).filter_by( disc_id=current_user()['id']).one_or_none() return None
def get_tournaments(): """returns all tournaments as json""" all_tournaments = Tournament.query.options(raiseload( Tournament.coaches)).filter(Tournament.status.in_( ("OPEN", "RUNNING"))).all() result = tournaments_schema.dump(all_tournaments) return etagjsonify(result.data)
def get_demo_board(): """Get a demo board""" demo_board_id = 1 query = Board.query.filter(Board.id == demo_board_id) query = query.options(joinedload(Board.tasks)).options(raiseload('*')) board = query.one() return BoardDetailsSchema().dump(board).data
def update_deck(deck_id): if current_user(): deck = Deck.query.get(deck_id) if deck is None: abort(404) if locked(deck): raise InvalidUsage('Deck is locked!', status_code=403) coach = Coach.query.options(raiseload(Coach.cards),raiseload(Coach.packs)).filter_by(disc_id=current_user()['id']).one_or_none() if deck.tournament_signup.coach!=coach: raise InvalidUsage("Unauthorized access!", status_code=403) received_deck = request.get_json()['deck'] deck = DeckService.update(deck,received_deck) result = deck_schema.dump(deck) return jsonify(result.data) else: raise InvalidUsage('You are not authenticated!', status_code=401)
def get(self): event_list = EventModel.query.options(raiseload('workshops')).all() return { "events": [ schemas.event_schema_without_workshops.dump(event).data for event in event_list ] }
def get_criteria_by_domain_id(self, domain_id): query = ( self.filter(DomainCriteria.domain_id == domain_id) .options( raiseload('*') ) .order_by(DomainCriteria.id.asc()) ) return query.all()
def query_contributions(ids=None): event_strategy = contains_eager(Contribution.event) event_strategy.joinedload(Event.own_venue) event_strategy.joinedload(Event.own_room).options(raiseload('*'), joinedload('location')) apply_acl_entry_strategy(event_strategy.selectinload(Event.acl_entries), EventPrincipal) session_strategy = joinedload(Contribution.session) apply_acl_entry_strategy( session_strategy.selectinload(Session.acl_entries), SessionPrincipal) session_strategy.joinedload(Session.own_venue) session_strategy.joinedload(Session.own_room).options( raiseload('*'), joinedload('location')) session_block_strategy = joinedload(Contribution.session_block) session_block_strategy.joinedload(SessionBlock.own_venue) session_block_strategy.joinedload(SessionBlock.own_room).options( raiseload('*'), joinedload('location')) session_block_session_strategy = session_block_strategy.joinedload( SessionBlock.session) session_block_session_strategy.joinedload(Session.own_venue) session_block_session_strategy.joinedload(Session.own_room).options( raiseload('*'), joinedload('location')) if ids is None: export_filter = ~Contribution.is_deleted & ~Event.is_deleted & _get_excluded_category_filter( ) else: export_filter = Contribution.id.in_(ids) return (Contribution.query.join(Event).filter(export_filter).options( selectinload(Contribution.acl_entries), selectinload(Contribution.person_links).joinedload( 'person').joinedload('user').load_only('is_system'), event_strategy, session_strategy, session_block_strategy, joinedload(Contribution.type), joinedload(Contribution.own_venue), joinedload(Contribution.own_room).options(raiseload('*'), joinedload('location')), joinedload(Contribution.timetable_entry), ).order_by(Contribution.id))
def get_approved_clients_by_user_id(user_id): return db.session.query(OAuthClient) \ .join(OAuthToken, OAuthToken.client_id == OAuthClient.client_id) \ .filter(OAuthToken.user_id == user_id, OAuthToken.revoked == False) \ .order_by(OAuthClient.client_name) \ .options(joinedload(OAuthClient.user) .load_only(User.first_name, User.last_name), raiseload("*")) \ .all() # noqa
def get_board(board_id, user_id): """Get a board""" query = Board.query.filter(Board.id == board_id, Board.user_id == user_id) query = query.options(joinedload(Board.tasks)).options(raiseload('*')) board = query.one_or_none() if not board: raise NotFoundError('Board not found.') return BoardDetailsSchema().dump(board).data
def get_function_by_id(self, function_id): # type: (int) -> Function return self._db.query(Function) \ .options(joinedload(Function.arguments), joinedload(Function.code_snippets), joinedload(Function.testing_input), raiseload('*')) \ .filter(Function.id == function_id) \ .first()
def search_for_rooms(filters, only_available=False): query = (Room.query .outerjoin(favorite_room_table, db.and_(favorite_room_table.c.user_id == session.user.id, favorite_room_table.c.room_id == Room.id)) .reset_joinpoint() # otherwise filter_by() would apply to the favorite table .options(raiseload('owner')) .filter(Room.is_active) .order_by(favorite_room_table.c.user_id.is_(None), db.func.indico.natsort(Room.full_name))) criteria = {} if 'capacity' in filters: query = query.filter(db.or_(Room.capacity >= (filters['capacity'] * 0.8), Room.capacity.is_(None))) if 'building' in filters: criteria['building'] = filters['building'] if 'floor' in filters: criteria['floor'] = filters['floor'] query = query.filter_by(**criteria) if 'text' in filters: query = query.filter(_make_room_text_filter(filters['text'])) if filters.get('equipment'): subquery = (db.session.query(RoomEquipmentAssociation) .with_entities(db.func.count(RoomEquipmentAssociation.c.room_id)) .filter( RoomEquipmentAssociation.c.room_id == Room.id, EquipmentType.name.in_(filters['equipment']) ) .join(EquipmentType, RoomEquipmentAssociation.c.equipment_id == EquipmentType.id) .correlate(Room) .as_scalar()) query = query.filter(subquery == len(filters['equipment'])) if filters.get('favorite'): query = query.filter(favorite_room_table.c.user_id.isnot(None)) if filters.get('mine'): ids = get_managed_room_ids(session.user) if ids: query = query.filter(Room.id.in_(ids)) query = _filter_coordinates(query, filters) if not only_available: return query start_dt, end_dt = filters['start_dt'], filters['end_dt'] repeatability = (filters['repeat_frequency'], filters['repeat_interval']) query = query.filter(Room.filter_available(start_dt, end_dt, repeatability, include_pre_bookings=True, include_pending_blockings=True)) if not rb_is_admin(session.user): selected_period_days = (filters['end_dt'] - filters['start_dt']).days booking_limit_days = db.func.coalesce(Room.booking_limit_days, rb_settings.get('booking_limit')) own_rooms = [r.id for r in Room.get_owned_by(session.user)] query = query.filter(db.or_(Room.id.in_(own_rooms) if own_rooms else False, db.and_(Room.filter_bookable_hours(start_dt.time(), end_dt.time()), db.or_(booking_limit_days.is_(None), selected_period_days <= booking_limit_days)))) return query
def __init__(self, session, q=None): """ :param sqlalchemy.orm.Session session: :param sqlalchemy.orm.Query q: """ self.session = session if q is None: self.q = session.query(User).options( raiseload(User.metering_points)) else: self.q = q
def commit_deck(deck_id): if not current_user(): raise InvalidUsage('You are not authenticated', status_code=401) deck = Deck.query.get(deck_id) if deck is None: abort(404) if locked(deck): raise InvalidUsage("Deck is locked!", status_code=403) coach = Coach.query.options(raiseload(Coach.cards),raiseload(Coach.packs)).filter_by(disc_id=current_user()['id']).one_or_none() if deck.tournament_signup.coach!=coach: raise InvalidUsage("Unauthorized access!!!!", status_code=403) try: deck = DeckService.commit(deck) except (DeckError) as e: raise InvalidUsage(str(e), status_code=403) result = deck_schema.dump(deck) return jsonify(result.data)
def get_deck(deck_id): if not current_user(): raise InvalidUsage('You are not authenticated', status_code=401) deck = Deck.query.get(deck_id) if deck is None: abort(404) coach = Coach.query.options(raiseload(Coach.cards),raiseload(Coach.packs)).filter_by(disc_id=current_user()['id']).one_or_none() if not deck.commited and not (coach.id==deck.tournament_signup.coach.id or coach.short_name()=="TomasT"): raise InvalidUsage("Deck not commited, only owner can display it!", status_code=403) # is committed if deck.tournament_signup.tournament.phase=="deck_building" and not (coach.id==deck.tournament_signup.coach.id or coach.short_name()==deck.tournament_signup.tournament.admin or coach.short_name()=="TomasT"): raise InvalidUsage("Only owner and admin can see display commited deck in the Deck Building phase!", status_code=403) starter_cards = CoachService.get_starter_cards(deck.tournament_signup.coach) result = deck_schema.dump(deck) result2 = cards_schema.dump(starter_cards) return jsonify({'deck':result.data, 'starter_cards':result2.data})
def tournament_resign(tournament_id): if current_user(): try: tourn = Tournament.query.get(tournament_id) coach = Coach.query.options(raiseload(Coach.cards),raiseload(Coach.packs)).filter_by(disc_id=current_user()['id']).one_or_none() if not coach: raise InvalidUsage("Coach not found", status_code=403) TournamentService.unregister(tourn,coach) signups = TournamentService.update_signups(tourn) if len(signups)>0: coaches = [signup.coach for signup in signups] msg = (", ").join([f"<@{coach.disc_id}>" for coach in coaches]) NotificationService.notify(f"{msg}: Your signup to {tourn.name} has been updated from RESERVE to ACTIVE") result = tournament_schema.dump(tourn) return jsonify(result.data) except RegistrationError as e: raise InvalidUsage(str(e), status_code=403) else: raise InvalidUsage('You are not authenticated', status_code=401)
def tournament_set_phase(tournament_id): if current_user(): try: tourn = Tournament.query.get(tournament_id) coach = Coach.query.options(raiseload(Coach.cards),raiseload(Coach.packs)).filter_by(disc_id=current_user()['id']).one_or_none() if not coach: raise InvalidUsage("Coach not found", status_code=403) if not coach.short_name()==tourn.admin: raise InvalidUsage("You are not admin for this tournament!", status_code=403) phase = request.get_json()['phase'] if phase not in ["deck_building","locked","special_play","inducement"]: raise InvalidUsage(f"Incorrect phase - {phase}", status_code=403) tourn.phase=phase db.session.commit() result = tournament_schema.dump(tourn) return jsonify(result.data) except (RegistrationError,TransactionError) as e: raise InvalidUsage(str(e), status_code=403) else: raise InvalidUsage('You are not authenticated', status_code=401)
def get_message_tags(message): """ """ tags_list = [] if message.source == "inbox": sms_tags = DB.session.query(SmsInboxUserTags).options( joinedload(SmsInboxUserTags.tag, innerjoin=True), raiseload("*") ).filter_by(inbox_id=message.inbox_id).all() tags_list = SmsInboxUserTagsSchema( many=True, exclude=["inbox_message"]).dump(sms_tags).data elif message.source == "outbox": sms_tags = DB.session.query(SmsOutboxUserTags).options( joinedload(SmsOutboxUserTags.tag, innerjoin=True), raiseload("*") ).filter_by(outbox_id=message.outbox_id).all() tags_list = SmsOutboxUserTagsSchema( many=True, exclude=["outbox_message"]).dump(sms_tags).data return tags_list
def tournaments_update(): """Update tournaments from sheet""" try: TournamentService.update() all_tournaments = Tournament.query.options( raiseload(Tournament.coaches)).filter( Tournament.status.in_(("OPEN", "RUNNING"))).all() result = tournaments_schema.dump(all_tournaments) return jsonify(result.data) except RegistrationError as exc: raise InvalidUsage(str(exc), status_code=403)
def tournament_close(tournament_id): """Close tournaments and award prizes""" try: tourn = Tournament.query.get(tournament_id) coach = current_coach() #prizes for prize in request.get_json(): tmp_coach = Coach.query.options(raiseload(Coach.cards), raiseload(Coach.packs)).get( prize['coach']) reason = prize['reason'] + " by " + coach.short_name() TransactionService.process(tmp_coach, int(prize['amount']) * -1, reason) TournamentService.close_tournament(tourn) result = tournament_schema.dump(tourn) return jsonify(result.data) except (RegistrationError, TransactionError) as exc: raise InvalidUsage(str(exc), status_code=403)
def get_repo_pulse_endpoint_pmh_recent(endpoint_id): version_filter = request.args.get("version", None) if version_filter: rows = PageNew.query\ .filter(PageNew.endpoint_id==endpoint_id, PageNew.scrape_version==version_filter)\ .order_by(PageNew.record_timestamp.desc())\ .limit(100) # deduplicate, because they don't care about the match type of the pages results = [r.to_dict(include_id=False) for r in rows] results = [dict(t) for t in {tuple(d.items()) for d in results}] else: rows = PmhRecord.query.options(raiseload('*')).filter(PmhRecord.endpoint_id==endpoint_id).order_by(PmhRecord.record_timestamp.desc()).limit(100) results = [r.to_dict() for r in rows] results = sorted(results, key=lambda k: k['oaipmh_record_timestamp'], reverse=True) return jsonify({"results": results})
def get_suppliers_by_name_keyword(self, keyword, framework_slug=None, category=None): query = (db.session.query(Supplier) .filter(Supplier.name.ilike('%{}%'.format(keyword.encode('utf-8')))) .filter(Supplier.status != 'deleted') .options( joinedload(Supplier.frameworks), joinedload(Supplier.domains), joinedload(Supplier.prices), joinedload('domains.domain'), joinedload('prices.service_role'), joinedload('frameworks.framework'), noload('frameworks.framework.lots'), raiseload('*'))) if framework_slug: query = query.outerjoin(SupplierFramework).outerjoin(Framework) query = query.filter(Framework.slug == framework_slug) if category: query = query.outerjoin(SupplierDomain) query = query.filter(SupplierDomain.domain_id == category).filter(SupplierDomain.status == 'assessed') query.order_by(Supplier.name.asc()).limit(20) return query.all()
def find_members(): return db.session.query(User) \ .filter_by(has_paid=True) \ .order_by(User.first_name) \ .options(raiseload('*')).all()
def search_for_rooms(filters, availability=None): """Search for a room, using the provided filters. :param filters: The filters, provided as a dictionary :param availability: A boolean specifying whether (un)available rooms should be provided, or `None` in case all rooms should be returned. """ query = (Room.query .outerjoin(favorite_room_table, db.and_(favorite_room_table.c.user_id == session.user.id, favorite_room_table.c.room_id == Room.id)) .reset_joinpoint() # otherwise filter_by() would apply to the favorite table .options(raiseload('owner')) .filter(Room.is_active) .order_by(favorite_room_table.c.user_id.is_(None), db.func.indico.natsort(Room.full_name))) criteria = {} if 'capacity' in filters: query = query.filter(Room.capacity >= filters['capacity']) if 'building' in filters: criteria['building'] = filters['building'] if 'division' in filters: criteria['division'] = filters['division'] query = query.filter_by(**criteria) if 'text' in filters: query = query.filter(_make_room_text_filter(filters['text'])) if filters.get('equipment'): subquery = (db.session.query(RoomEquipmentAssociation) .with_entities(db.func.count(RoomEquipmentAssociation.c.room_id)) .filter( RoomEquipmentAssociation.c.room_id == Room.id, EquipmentType.name.in_(filters['equipment']) ) .join(EquipmentType, RoomEquipmentAssociation.c.equipment_id == EquipmentType.id) .correlate(Room) .as_scalar()) query = query.filter(subquery == len(filters['equipment'])) if filters.get('features'): for feature in filters['features']: query = query.filter(Room.available_equipment.any(EquipmentType.features.any(RoomFeature.name == feature))) if filters.get('favorite'): query = query.filter(favorite_room_table.c.user_id.isnot(None)) if filters.get('mine'): ids = get_managed_room_ids(session.user) query = query.filter(Room.id.in_(ids)) query = _filter_coordinates(query, filters) if availability is None: return query start_dt, end_dt = filters['start_dt'], filters['end_dt'] repeatability = (filters['repeat_frequency'], filters['repeat_interval']) availability_query = Room.filter_available(start_dt, end_dt, repeatability, include_pre_bookings=True, include_pending_blockings=True) if availability is False: availability_query = ~availability_query query = query.filter(availability_query) if not rb_is_admin(session.user): selected_period_days = (filters['end_dt'] - filters['start_dt']).days booking_limit_days = db.func.coalesce(Room.booking_limit_days, rb_settings.get('booking_limit')) own_rooms = [r.id for r in Room.get_owned_by(session.user)] query = query.filter(db.or_(Room.id.in_(own_rooms) if own_rooms else False, db.and_(Room.filter_bookable_hours(start_dt.time(), end_dt.time()), Room.filter_nonbookable_periods(start_dt, end_dt), db.or_(booking_limit_days.is_(None), selected_period_days <= booking_limit_days)))) return query