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
