def pop_up(user, pop_type, user_city):
"""
获取是否弹框提示
每周只弹一次
:param user:
:param pop_type:
:return:
"""
info = Struct()
info.status = 0
unit = user.unit
if not unit or unit.grade_id > 6:
return info
key = (user.id, pop_type, get_weekend_stamp())
data = cache.hd_full_pop_up.get(key)
if not data:
cache.hd_full_pop_up.set(key, '1')
if pop_type == "home":
data = pk_pop(user.id, user_city)
return data
if pop_type == "click":
user_grade(user.id)
info.status = 1
if pop_type == "info":
key = (user.id, "click", get_weekend_stamp())
data = cache.hd_full_pop_up.get(key)
if not data:
info.status = 1
return info
def p_version(request):
"""
@api {get} /system/version [系统]检查版本
@apiGroup system
@apiParamExample {json} 请求示例
{"type":客户端类型, "api":客户端当前内部版本号}
type客户端类型:
9安卓学生 10安卓教师 11苹果学生 12苹果教师 13 H5学生 14 H5教师 15 H5活动 16 H5学测评学生 17 H5学测评教师
@apiSuccessExample {json} 成功返回
{
"message": "",
"next": "",
"data": {
"title": "同步课堂手机客户端",
"last_version": "2.3.12",
"release_date": "2016-06-27 10:55:04",
"update": 2, # 0:不更新 1:选择性更新 2:强制更新
"content": "2.2.3巫妖王",
"download": "http://file.tbkt.cn/upload_media/apk/tbkt_stu_android/tbkt_stu_android-release-16.apk"
},
"response": "ok",
"error": ""
}
@apiSuccessExample {json} 失败返回
{
"message": "找不到该类型的版本信息",
"next": "",
"data": "",
"response": "fail",
"error": ""
}
"""
args = request.QUERY.casts(type=int, api=int)
type = args.type or 0
user_api = args.api or 0
version = db.slave.system_version.filter(type=type).order_by(
'api', 'release_date').last()
if not version:
return ajax.jsonp_fail(request, message="找不到该类型的版本信息")
data = Struct()
data.last_version = version.version
data.release_date = version.release_date
data.title = version.title
data.content = version.content
data.download = version.download
data.update = 0 # 0:不更新 1:选择性更新 2:强制更新
min_version = db.slave.system_version.filter(type=type, must=1).order_by(
'api', 'release_date').last() # 最低版本
if min_version and user_api < min_version.api:
data.update = 2 # 用户版本小于系统设置最低版本则强制更新
elif user_api < version.api: # 小于最新版本
data.update = 2 if version.must else 1 # 根据最新版本设置返回是否需要强制更新
return ajax.jsonp_ok(request, data)
def r_info(request):
"""
@api /huodong/sx/normal/com/info [数学常态活动]积分信息
@apiGroup math_normal
@apiSuccessExample {json} 成功返回
{
"message": "",
"next": "",
"data": {
"score": 0, # 用户积分
"num": 0,
"top": 0
},
"response": "ok",
"error": ""
}
"""
user, active_id = base(request)
out = Struct()
out.open_add = -1
if user.type == 1:
out.open_add = common.stu_open_add_score(user)
info = common.get_user_score(user, active_id)
out.score = info.score
cost = TEA_LOTTERY_COST if user.is_teacher else STU_LOTTERY_COST
out.num = info.score/cost
out.top = info.rank_no
out.user_id=user.id
out.is_teacher = user.is_teacher
return ajax_json.jsonp_ok(request, out)
def get_status(user):
"""
是否可以参加活动领金币
:param user_id:
:return:
"""
# 三门峡用户不参加此次活动
data = Struct()
sid = user.subject_id
data.status = 0
num = db.tbkt_active.active_score_gift.select("end_num").get(active_id=14)
data.num = num.end_num
region = db.ketang_slave.mobile_order_region.get(user_id=user.id)
if region and region.city == "411200":
return u"三门峡用户不参与此次活动"
# 教师所在班级人数不足，不能参加活动
unit_ids = [u.id for u in user.units]
if sid == 21 and sx_task_info(user, unit_ids):
data.status = 1
if sid == 51 and yw_task_info(user, unit_ids):
data.status = 1
if sid == 91 and yy_task_info(user, unit_ids):
data.status = 1
if num.end_num == 0:
data.status = 0
user_coin = db.default.score_user_detail.get(user_id=user.id, app_id=7, remark=u"教师发作业赢金豆")
if user_coin:
data.status = 2
return data
def get_qg_tiyan_day(user, subject_ids):
if not user:
return {}
third = db.user_slave.third_user.select('third_id').get(user_id=user.id, platform_id=6)
ord_province = user.get_mobile_order_region().select('province').order_by('-add_date').get(user_id=user.id)
province = db.user_slave.third_common_provincecity.select('third_cityid').get(cityid=ord_province.province,
platform_id=6)
if not third or not ord_province or not province:
return {}
hub = tbktapi.Hub()
url = '/api/getopentotal/'
data = dict(
third_id=third.third_id,
province_id=province.third_cityid,
from_type=4,
platform_id=6
)
r = hub.qg.post(url, data)
if not r:
return {}
if r.respones == 'fail':
return {}
try:
logging.info(r.data)
data = r.data.get('productInfos', '')
if not data:
r = hub.qg.post(url, data)
data = r.data.get('productInfos', '')
if not data:
return {}
data = map(Struct, data)
out = []
for i in data:
arg = Struct()
produce_id = int(i.productId)
sid = PRODUCT.get(produce_id, 0)
if int(sid) != int(subject_ids):
continue
else:
arg.sid = sid
arg.status, arg.tiyan_day = get_qg_tiyan_range(i, user)
out.append(arg)
return out
except Exception as e:
logging.error('/api/getopentotal/ ERROR %s' % e)
return []
def pk_num(user_id, week_id):
"""
竞技用户第几回合 剩余机会
:param user_id:
:param week_id:
:return:
"""
data = Struct()
test_num = db.tbkt_active.full_score_test.select("score", "week_id", "text") \
.filter(user_id=user_id, week_id=week_id, type=3, status=1, grade_id=user_grade(user_id)).count()
data.num = test_num + 1
data.have_chance = 2 - test_num
if data.have_chance <= 0:
data.have_chance = 0
return data
def test_result(user_id, week_id):
"""
测试结果页
:param user_id:
:param week_id:
:return:
"""
grade_id = user_grade(user_id)
question = get_knowledge_question(week_id, grade_id)
out = Struct()
out.info = question
out.wrong_name = []
# 用户的答题记录 取出用户答案
test = db.tbkt_active.full_score_test.select("text").get(user_id=user_id,
week_id=week_id,
grade_id=grade_id,
status=1,
type=2)
if not test:
return out
text = map(Struct, json.loads(test.text))
wrong_kids = []
test_map = {}
for i in text:
if i.display_type == 2:
# 填空题类型 将答案格式化成数组
i.result = i.result.split(',')
if i.is_right == 0:
wrong_kids.append(i.kid)
# {kid: 对应用户答案}
test_map[i.kid] = i.result
# 取出知识点视频
know_info = get_source(week_id, grade_id)
know_map = {i.id: i for i in know_info}
wrong_name = []
for i in out.info:
k = know_map.get(i.knowledge_id)
i.video_url = k.video_url
i.name = k.name
user_answer = test_map.get(i.knowledge_id)
if i.display_type == 2:
i.content = filling(i.content, user_answer, i.answer)
i.user_answer = user_answer
if i.knowledge_id in wrong_kids:
wrong_name.append(i.name)
out.wrong_name = wrong_name
return out
def get_cities(province='410000', child=0):
"""
获得地市列表
-------------------------
王晨光 2016-12-06
-------------------------
@param province 默认河南省410000
@param child 1附带县区数据
@return [{id:县区行政编码, name:县区名, child:[]}]
"""
qs = db.slave.common_provincecity.filter(fatherId=province).select(
'id', 'cityId', 'name')
cities = [
Struct({
'id': city.cityId,
'name': city.name,
'child': []
}) for city in qs
]
# 地市数据
if child:
cityd = {c.id: c for c in cities}
city_ids = [c.id for c in cities]
counties = db.slave.common_provincecity.filter(
fatherId__in=city_ids).select('fatherId', 'cityId', 'name')[:]
for county in counties:
city = cityd[county.fatherId]
county_data = {'id': county.cityId, 'name': county.name}
city.child.append(county_data)
return cities
def get(self, path, params=None, **kwargs):
"""Sends a GET request.
:param path: 接口路径(比如 "/account/profile")
:param params: (optional) Dictionary or bytes to be sent in the query string.
:param json: (optional) json data to send in the body.
:param kwargs: 可选参数, 比如timeout, cookies, headers...
:return: 成功返回同步课堂ajax格式的字典, 比如:
{
"message": "",
"next": "",
"data": {},
"response": "ok",
"error": ""
}
"""
url = self.urlroot + path
if self.headers:
if 'headers' in kwargs:
headers = self.headers.copy()
headers.update(kwargs['headers'])
else:
headers = self.headers
kwargs['headers'] = headers
if self.cookies:
if 'cookies' in kwargs:
cookies = self.cookies.copy()
cookies.update(kwargs['cookies'])
else:
cookies = self.cookies
kwargs['cookies'] = cookies
r = requests.get(url, params, **kwargs)
assert r.status_code == 200, r.status_code
return Struct(r.json())
def index(user, app_id):
"""
:param user:
:return:
"""
data = Struct()
# 未参加用户默认排名为0分数为0
data['score'] = 0
data['rank_no'] = 0
score_user = db.default.score_user.select('score').get(user_id=user.id, app_id=app_id)
if not score_user:
return data
else:
sql = '''
SELECT
s.user_id,s.score
FROM
(SELECT user_id,MAX(add_date) AS add_date FROM score_user_detail WHERE app_id=37 GROUP BY user_id) AS p
INNER JOIN
score_user s
ON s.user_id=p.user_id AND s.app_id=37
ORDER BY -s.score,p.add_date;
'''
score_user = db.default.fetchall_dict(sql)
for su in score_user:
data['rank_no'] += 1
if su.user_id == user.id:
data['score'] = su.score
return data
def get_user_border(user_id):
# 获取用户头像边框url
data = Struct()
border_id = db.slave.user_border_detail.select('border_id').get(
user_id=user_id, status=1)
if not border_id:
data.url = ''
else:
border_url = db.slave.border.select('border_url').get(
id=border_id.border_id)
if border_url:
data.url = get_absurl(border_url.border_url)
else:
data.url = ''
return data
def get_my_things(user_id):
# 获取用户道具 奖品 积分记录
#道具
data = Struct()
props = db.tbkt_active.winter_tools.select('tools').get(user_id=user_id)
data['props'] = decode_json_get_value(props.tools)
#奖品
awards = db.tbkt_active.winter_user_award.select(
'award_id', 'add_time').filter(user_id=user_id)[:]
# [{award_id = 1},{}]
if not awards:
data['awards'] = []
else:
award_id = []
for award in awards:
award_id.append(award.award_id)
award_names = db.tbkt_active.winter_award.select('name').filter(
id__in=award_id)[:]
for i in range(len(awards)):
awards[i]['name'] = award_names[i]['name']
awards[i]['add_time'] = get_day(awards[i]['add_time'])
awards[i]['add_month'] = get_month(awards[i]['add_time'])
data['awards'] = awards
return data
def draw_award(self, award_sort=None, once=1, default_award=None):
"""
抽奖
:param award_sort:[{award_type:1,rate:0.001,total:3,day_num:1, is_award: 1}]
award_type:几等奖，rate:中奖比例，total: 奖品总量，day_num: 单日奖品发放量，-1 为不限量
is_award: 1 是奖品，0 谢谢参与
:param once : 同一个奖品，用户是否只能中奖一次，默认是
:param default_award: 重复中奖/超出日发奖范围/超出总数 后 改为中奖默认值，
"""
able, why = self.award_able
if not able:
return False, why
deduct = self._deduct_score()
if not deduct:
return False, u'扣分失败'
# 获取奖品名称
award_sort = self.add_award_detail(award_sort)
if not default_award:
default_award = Struct(name=u'谢谢参与',
award_type=len(award_sort) + 1,
status=1,
rate=1,
total=-1,
day_num=-1,
is_award=0)
award = self._probability(award_sort, default_award, once)
result = self._draw(award, default_award)
return True, result
def user_pk_index(user_id, week_id, grade_id, user_city):
"""
获取用户分数下标 取前后排名用户
:param user_id:
:param week_id:
:param user_city:
:param grade_id:
:return:
"""
data = Struct()
data.score = 0
# 获取用户周竞技提交分数 判断所有分数是否在同一地市
submit_score = db.tbkt_active.full_score_test.select(
"user_id", "city").filter(week_id=week_id,
type=3,
status=1,
user_id=user_id,
grade_id=grade_id)[:]
if not submit_score:
return []
for i in submit_score:
if i.city != user_city:
db.tbkt_active.full_score_test.filter(
user_id=user_id, week_id=week_id, grade_id=grade_id,
type=3).update(city=user_city)
score = db.tbkt_active.full_score_test.select(
"user_id", "score",
"city").filter(week_id=week_id,
type=3,
status=1,
grade_id=grade_id,
city=user_city).order_by('-score', "id")[:]
temp = []
user_rank = []
for s in score:
if s.user_id in temp:
continue
else:
user_rank.append(s)
temp.append(s.user_id)
for i, k in enumerate(user_rank):
if k.user_id == user_id:
user_index_info = i
user_info = k
return user_index_info, user_info
def get_pk_question(user_id, week_id):
"""
获取周竞技题目信息
:param user_id:
:param week_id:
:return:
"""
grade_id = user_grade(user_id)
info = db.tbkt_active.full_score_week_detail.get(week_id=week_id,
grade_id=grade_id)
if not info:
return
pk_qid = info.week_qid.split(',')
data = Struct()
out = get_question_info(pk_qid)
data.out = out
data.num = pk_num(user_id, week_id).num
pk_score = db.tbkt_active.full_score_test.select("score", "week_id", "text", "use_time") \
.filter(user_id=user_id, week_id=week_id, type=3, grade_id=grade_id, status=0).last()
if not pk_score:
return data
out_map = map(Struct, json.loads(pk_score.text))
# data.q_info = out_map
data.use_time = pk_score.use_time
if pk_score.use_time == 0:
data.use_time = 300
added_aid = [i.aid for i in out_map]
un_finish = []
for i in out:
if i.id in added_aid:
continue
un_finish.append(i)
data.out = un_finish
return data
def get_rank(user_id, week_id, user_city):
"""
周末排行
:return:
"""
data = Struct()
data.user_rank = []
data.my_rank = []
# 取出地市所有用户排名
user_rank = rank_user_id(user_id, week_id, user_city)
if not user_rank:
return data
for i, v in enumerate(user_rank):
v.rank = i + 1
user_ids = [i.user_id for i in user_rank]
user = users_info(user_ids)
user_map = {i["user_id"]: i for i in user}
for i in user_rank:
info = user_map.get(i.user_id)
i.portrait = info["portrait"]
i.school_name = info["school_name"]
i.unit_name = info["unit_name"]
i.border_url = info["border_url"]
i.real_name = info["real_name"]
if i.user_id == user_id:
data.my_rank = i
data.user_rank = user_rank
if not data.my_rank:
data.my_rank = my_rank_info(user_id, week_id, user_city)
return data
def get_user_details(user_id, way, pageno, pagesz=10):
"""
获取用户积分明细
-----------------------
王晨光 2016-12-07
-----------------------
:param user_id: 用户ID
:param way: 明细分类(1收入 2支出 0全部)
:param pageno: 页号
:param pagesz: 每页条数
:return: {balance:余额, pagecount:总页数, details:[detail]}
"""
us = db.slave.score_user.get(app_id=APPID, user_id=user_id)
balance = us.score if us else 0
details = db.slave.score_user_detail.filter(app_id=APPID, user_id=user_id)
if way == 1:
details = details.filter(item_no='tea_voucher_bak')
elif way == 2:
details = details.filter(item_no='tea_voucher')
n = details.count()
pagecount = int(math.ceil(1.0 * n / pagesz))
details = details.order_by('-id')[(pageno - 1) * pagesz:pageno * pagesz]
rows = []
for d in details:
item_no = d.item_no
score = d.score
theway = 0 # 0收入 1支出
if item_no == 'tea_voucher':
title = u"支出%s金豆" % score
theway = 1
elif item_no == 'tea_voucher_bak':
title = u"收入%s金豆" % score
row = Struct()
row.id = d.id
row.item_no = d.item_no
row.way = theway
row.title = title
row.score = score
row.remark = d.remark
row.add_date = from_unixtime(d.add_date).strftime('%Y-%m-%d %H:%M')
rows.append(row)
out = {
'balance': balance,
'pageno': pageno,
'pagecount': pagecount,
'details': rows
}
return out
def get_ask_explain(ask_id, paper_id):
"""
:param ask_id:
:param paper_id:
:return:
"""
sql = """
select a.subject a_subject, a.content a_content, a.image_url a_image_url,
q.subject q_subject, q.content q_content, q.image_url q_image_url
from sx2_question_ask a, sx2_question q
where a.id = %s and a.question_id = q.id
""" % ask_id
row = db.ziyuan_slave.fetchone_dict(sql)
if not row:
return []
paper_number = get_paper_number(paper_id)
out = Struct()
num = paper_number.get(ask_id) if paper_number else ""
out.q_num = num.q_num if num else ''
out.a_num = num.a_num if num else ''
out.big_subject = parse_subject(
row.q_subject) if row.q_subject else parse_new_subject(
row.q_content, row.q_image)
out.small_subject = parse_subject(
row.a_subject) if row.a_subject else parse_new_subject(
row.a_content, row.a_image)
out.ask_id = ask_id
return out
def openstatus(self, subject_id):
"""获取指定科目开通状态"""
hub = tbktapi.Hub(self.request)
param = dict(subject_id=subject_id, platform_id=self.platform_id)
r = hub.bank.get('/status', param)
if not r:
return 0
data = Struct(r.data[0])
return data.status
def get_user_props(user_id):
"""返回用户道具数量"""
user_props = db.tbkt_active.active_user_props.filter(
active_id=ACTIVE_ID, user_id=user_id).select('item_no', 'name',
'num')[:]
user_props_map = {i.item_no: i for i in user_props}
prop_rank = {'hat': 1, 'clothes': 2, 'shoe': 3, 'glove': 4, 'bag': 5}
props = user_props_map.values()
for k in PROPS_REMARK.keys():
if k not in user_props_map:
o = Struct()
o.item_no = k
o.name = PROPS_REMARK[k]
o.num = 0
props.append(o)
props.sort(key=lambda x: prop_rank.get(x.item_no))
return props
def r_stu_test_info(request):
"""
@api {post} /huodong/terminal/yw/test/info [期末提分试卷]语文学生做题
@apiGroup terminal
@apiParamExample {json} 请求示例
{"task_id": 作业id}
@apiSuccessExample {json} 成功返回
{
"message": "",
"next": "",
"data": {
"total": 10, # 全部试题
"wrong": 2, # 错题数
"title": "期末提分试卷-（二）", # 试卷标题
},
"response": "ok",
"error": ""
}
"""
out = Struct()
out.total = 0
out.wrong = 0
out.title = ""
args = request.QUERY.casts(task_id=int, test_id=int)
task_id = args.task_id
test_id = args.test_id
if not task_id and not test_id:
return ajax.jsonp_fail(request, message="缺少作业id")
if task_id:
user_id = request.user_id
detail = db.tbkt_yuwen.yw_test_detail_new.get(task_id=task_id,
user_id=user_id)
else:
test = db.tbkt_yuwen.yw_test_new.get(id=test_id)
task_id = test.task_id
detail = db.tbkt_yuwen.yw_test_detail_new.get(task_id=test.task_id,
user_id=test.user_id)
if not detail or detail.status == 0:
return ajax.jsonp_ok(request, out)
sql = """
select t.title, d.question_id from yw_task_new t, yw_task_detail_new d
where t.id = d.task_id and t.id = %s
""" % task_id
task = db.tbkt_yuwen.fetchone_dict(sql)
if not task or not task.question_id:
return ajax.jsonp_ok(request, out)
question_ids = map(int, task.question_id.split(","))
text = map(Struct, json.loads(
detail.text)) if detail and detail.text else []
out.total = len(question_ids)
out.wrong = len(set(i.qid for i in text if i.result == 0))
out.title = task.title
return ajax.jsonp_ok(request, out)
def get_or_creat_test(user_id, paper_Id):
"""创建测试记录"""
test = db.tbkt_web.active_test.get(active_id=ACTIVE_ID,
object_Id=paper_Id,
user_id=user_id)
if test:
return test
paper = db.ziyuan.sx_paper.get(id=paper_Id)
test_id = db.tbkt_web.active_test.create(active_id=ACTIVE_ID,
object_Id=paper_Id,
user_id=user_id,
title=paper.name,
status=-1,
add_time=int(time.time()))
test = Struct()
test.id = test_id
test.status = 0
test.title = paper.name
return test
def pk_week_rank(user_id, week_id, user_city):
"""
1-5 6-7 排行
:param user_id:
:param week_id:
:param user_city:
:return:
"""
# 获取当前时间 周一至周五top 周末实时
data = Struct()
data.user_rank = []
data.my_rank = []
week_day = datetime.date.today().weekday()
if week_day in (0, 1, 2, 3, 4):
data = week_rank(user_id, week_id, user_city)
return data
if week_day in (5, 6):
data = get_rank(user_id, week_id, user_city)
return data
def parse_option(op_content):
"""解析选项内容
:returns: {'content':内容, 'image':{'url':图片地址, 'align':''}, 'option':'A', 'is_right':1或0}
"""
if not op_content:
return {}
option = json.loads(op_content) or {}
option = Struct(option)
option["content"] = replace_symbol(option.get("content", ""))
images = option.pop("images", [])
if images:
image = images[0]
image['url'] = format_url(image['url'])
else:
image = {}
option['image'] = image
option['is_right'] = int(option.get('is_right') or 0)
return option
def get_knowledge_list(user_id, week_id):
"""
获取知识训练场列表数据
:param user_id:
:param week_id:
:return:
"""
grade_id = user_grade(user_id) # 获取用户设置教材id
out = Struct()
out.info = [] # 视频信息列表
out.test_status = test_info(user_id, week_id, grade_id) # 测试完成状态
out.finish_status = 0 # 视频完成状态
out.q_num = 0
source = get_source(week_id, grade_id) # 获取课程资源
if not source:
return out
test = db.tbkt_active.full_score_test.select("text").get(user_id=user_id,
week_id=week_id,
grade_id=grade_id,
type=1)
out.finish_status = 1 if test else 0
for i, v in enumerate(source):
if not test:
if i == 0:
status = 0
else:
status = -1
else:
text = test.text.split(",")
if i == 0:
if str(v.id) in text:
status = 1
else:
status = 0
else:
if str(source[i - 1].id) in text:
status = 0
if str(source[i].id) in text:
status = 1
else:
status = -1
v.status = status
out.info = source
out.q_num = len(out.info)
return out
def get_type(user_id):
# 看下一场参加啥项目 单数参加成语 双数参加唐诗
type = db.tbkt_active.winter_pk_record_new.select('id').filter(
user_id=user_id, type=3).count()
if type % 2 == 0:
type = 1
else:
type = 2
data = Struct()
data['type'] = type
return data
def get_wrong_question(user_id, week_id, grade_id):
"""
获取高频试题资源
:param week_id:
:param grade_id:
:param user_id:
:return:
"""
# 获取题目信息
data = get_wrong_source(week_id, grade_id)
if not data:
return []
test = db.tbkt_active.full_score_test.select('text').get(user_id=user_id,
week_id=week_id,
grade_id=grade_id, type=WRONG_TYPE)
if test and test.status == 1:
# 用户已完成当前练习
return []
text = json.loads(test.text) if test and test.text else []
text_map = defaultdict(dict)
for i in text:
temp = Struct(i)
text_map[str(temp.qid)].update({temp.aid: (temp.option, temp.result)})
qids = [str(i.get("qid")).strip() for i in text]
qid_map = {str(i.get("qid")).strip(): (i.get("count"), i.get("ratio", "75%")) for i in data if i.get("qid")}
source_qids = [str(i.get("qid")).strip() for i in data]
r = Hub().sx.get("/sx/questions", dict(qid=join(source_qids)))
if not r or r.response != "ok":
return []
questions = map(Struct, r.data)
questions = [i for i in questions if i not in qids]
print [i.id for i in questions]
out = []
for i in questions:
q = text_map.get(str(i.id))
asks = map(Struct, i.asks)
if q and len(asks) == len(q):
continue
if not qid_map.get(str(i.id)):
continue
i.count, i.ratio = qid_map.get(str(i.id))
temp = int(i.ratio.replace("%", ""))
i.ratio = "%s%%" % (temp + 20) if temp <= 55 else i.ratio
i.count = random.randint(217, 500) + i.count
for ask in asks:
option, result = q.get(ask.id, ("", "")) if q else ("", "")
ask.user_answer = option
ask.user_result = result
i.asks = asks
out.append(i)
return out
def get_user_score(user, active_id):
"""
获取用户积分
——————————————————
王世成 2017.9.12
——————————————————
:param user: 用户对象
:param active_id: 对应活动id
:return:
"""
rank = Struct(get_user_rank(active_id, user.id))
return rank
def knowledge_qid_info(user_id, week_id):
"""
获取知识训练场知识点题目信息
:param user_id:
:param week_id: 获取题目的week_id
:return:
"""
grade_id = user_grade(user_id)
out = Struct()
questions = get_knowledge_question(week_id, grade_id)
# return questions
out.q_num = len(questions)
out.info = questions
test = db.tbkt_active.full_score_test.get(user_id=user_id,
week_id=week_id,
grade_id=grade_id,
type=2)
if not test:
return out
if test and test.status == 1:
out.info = []
return out
txt = json.loads(test.text) if test.text else []
qid = [i.get("qid") for i in txt]
out.info = [i for i in out.info if i.id not in qid]
return out
def post_pk_details(user_id, add_time, right_num, user_time, score,
user_object, pk_user, result, school_id, province_id,
class_id, is_type, pk_id):
"""
:param user_id: 用户id
:param add_time: pk开始时间
:param right_num: 答对题数
:param user_time: 时长
:param score: 总数
:param user_object: 用户的信息:头像路径、姓名、user_id、学校名称
:param pk_user: 挑战对象的信息:头像路径、姓名、user_id
:param result: 结果1.赢了，2.输了
:param school_id: 学校id
:param province_id: 省份id
:param class_id: 班级id
:param is_type: 1.诗词大战pk,2.成语游戏pk
:return:
"""
# 增加用户对战记录，增加用户积分以及道具，增加积分明细和道具明细
add_time = int(time.time())
pk_record_id = db.tbkt_active.winter_pk_record_new.create(
type=is_type,
user_id=user_id,
right_num=right_num,
user_time=user_time,
score=score,
user_object=json.dumps(user_object),
pk_user=json.dumps(pk_user),
result=result,
add_time=add_time,
school_id=school_id,
class_id=class_id,
province_id=province_id)
if result == 1:
score = score + 5
# 胜利随机给1个道具增加与记录增加
add_type = random.randint(1, 6)
props_dict = {add_type: 1}
operate_props(user_id, 1, props_dict, add_time, 2)
else:
add_type = 0
# 积分增加与记录增加
if pk_id:
db.tbkt_active.winter_user_score_detail.filter(id=pk_id).delete()
coin_id = operate_coin(user_id, 1, score, add_time, 2)
data = Struct()
data['add_type'] = add_type
coin_id.append(pk_record_id)
data['ids'] = coin_id
return data
