def load_data():
module = request.get_json()
if 'group' in module:
try:
gt = 'group'
lb = module['label']
except (KeyError, ValueError):
h = hash(frozenset(int(i) for i in module['group']))
gt = 'hgrp'
lb = '%05d' % (h % 100000)
rd.sadd('{}s'.format(gt), lb)
rd.sadd('%s:%s' % (gt, lb), *module['group'])
return json.jsonify({
'status': 'ok',
})
if not Module.query.get(module['code']):
db.session.add(Module(**module))
sections = []
for cn, section in module['sections'].items():
try:
cn = int(cn)
except ValueError:
continue
sct = Section.query.get(cn)
if not sct:
db.session.add(Section(**{
'class_no': cn,
'name': section['name'],
'mod_code': module['code']
}))
db.session.commit()
else:
sct.last_updated = datetime.now()
Lesson.query.filter_by(class_no=cn).delete()
sections.append(section['name'])
for i in section['schedule']:
d = get_int(i['d'])
dts = tuple(datetime(*(d+get_int(i[l]))) for l in 'se')
db.session.add(Lesson(**{
'dts': dts,
'class_no': cn,
'location': i['l'],
'component': i['c'],
}))
db.session.commit()
return json.jsonify({
'status': 'ok',
})
def _cache_user_posts(id: IntLike):
key = Keys.user_statuses.format(id)
sql = "select id from statuses where user_id=:UID order by id"
result = db.engine.execute(text(sql), UID=id)
statuses_ids = [row[0] for row in result]
statuses_ids.append(-1)
rd.sadd(key, *statuses_ids)
rd.expire(key, Keys.user_statuses_expire)
def _cache_liked_users(id: IntLike):
key = KEYS.status_liked_users.format(id)
sql = 'select user_id from status_likes where status_id=:SID'
result = db.engine.execute(text(sql), SID=id)
liked_user_ids = [row[0] for row in result]
liked_user_ids.append(-1)
rd.sadd(key, *liked_user_ids)
rd.expire(key, KEYS.status_liked_users_expire)
def _cache_account_subscribers(id: IntLike):
key = KEYS.official_account_subscribers.format(id)
sql = """
select users_id from subscriptions
where official_account_id=:OID
"""
result = db.engine.execute(text(sql), OID=id)
subscriber_ids = [row[0] for row in result]
subscriber_ids.append(-1)
rd.sadd(key, *subscriber_ids)
rd.expire(key, KEYS.official_account_subscribers_expire)
def _cache_followers(id: IntLike):
key = Keys.user_followers.format(id)
sql = "select follower_id from user_follows where followed_id=:UID"
result = db.engine.execute(text(sql), UID=id)
follower_ids = [row[0] for row in result]
"""
As redis does not support empty set, but we
still need to know whether an empty set is cached,
so we need a placeholder element(use self's id is good)
"""
follower_ids.append(id)
rd.sadd(key, *follower_ids)
rd.expire(key, Keys.user_followers_expire)
def load_data():
module = request.get_json()
if not Module.query.get(module['code']):
db.session.add(
Module(**{'code': module['code'], 'title': module['title']})
)
sections = []
grp_sect = []
for cn, section in module['sections'].items():
cn = int(cn)
sct = Section.query.get(cn)
if not sct:
db.session.add(Section(**{
'class_no': cn,
'name': section['name'],
'mod_code': module['code']
}))
db.session.commit()
else:
sct.last_updated = datetime.now()
Lesson.query.filter_by(class_no=cn).delete()
sections.append(section['name'])
grp_sect.append(cn)
sn = 0
for i in section['schedule']:
d = tuple(int(n) for n in reversed(i['d'].split('.')))
dts = [datetime(*(d+tuple(map(int,i[l].split('.'))))) for l in 'se']
db.session.add(Lesson(**{
'class_no': cn, 'sn': sn, 'dts': dts,
'location': i['l'], 'component':i['c'],
}))
sn += 1
db.session.commit()
gtime = int(time())
rd.sadd('tgrps', gtime)
rd.sadd('tgrp:%s'%gtime, *grp_sect)
return json.jsonify({
'status': 'ok', 'loaded': (module['code'], ', '.join(sections))
})
def groupadd(name, members):
"""Add to group"""
rd.sadd('groups', name)
if len(members) == 1 and ':' in members[0]:
members = tuple(rd.smembers(members[0]))
rd.sadd('group:%s'%name, *members)