def create_subjective_options(ask_id):
"""
构造主观题选项
[{id:0, content:'', image:{}, 'option':'A', 'is_right':1或0}]
"""
return [
Struct({
'ask_id': ask_id,
'id': 0,
'content': u'我答对了',
'image': {},
'option': u'A',
'is_right': 1
}),
Struct({
'ask_id': ask_id,
'id': 0,
'content': u'我答错了',
'image': {},
'option': u'B',
'is_right': 0
}),
]
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 pk_pop(user_id, user_city):
"""
用户pk弹框
:param user_id:
:param user_city:
:return:
"""
# 本周一的时间戳
with db.default as dd:
data = Struct()
data.status = 0
data.border_url = ""
data.border_id = 0
# 获取上周前100名的用户id
b_time, _ = time_stamp()
week = db.tbkt_active.full_score_week_list.select("id").filter(begin_time__lt=b_time)\
.order_by("-begin_time").first()
if not week:
return data
rank_id = rank_user_id(user_id, week.id, user_city)
if not rank_id:
return data
user_ids = [i.user_id for i in rank_id]
if user_id in user_ids:
# 获取竞技边框信息
border = dd.border.get(remark="竞技", status=1)
if not border:
return data
# 竞技边框 id
border_id = border.id
# 竞技边框url
border_url = get_absurl(border.border_url)
# 保存前100名用户获取竞技头像之前的边框
user_border = dd.user_border_detail.get(user_id=user_id, status=1)
if user_border:
# 如果用户用使用中的边框，则更新上次使用状态改为1
dd.user_border_detail.filter(id=user_border.id).update(
once_border_id=1)
get_pk_border = dd.user_border_detail.get(user_id=user_id,
border_id=border_id)
if get_pk_border:
return data
dd.user_border_detail.create(user_id=user_id,
border_id=border_id,
add_time=int(time.time()))
data.border_url = border_url
data.border_id = border_id
data.status = 1
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_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_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_depts(school_id):
"""
获得部门列表
-------------------------
王晨光 2016-12-21
-------------------------
@param school_id 学校ID
@return [{id:部门ID, name:部门名称}]
"""
school = db.slave.school.get(id=school_id)
if not school:
return []
depts = db.slave.school_unit_class.filter(school_id=school_id,
level_id=1,
unit_type=1).order_by('type')[:]
if not depts:
# 创建部门节点
type_dict = {
1: u'小学部',
2: u'初中部',
3: u'高中部',
4: u'大学部',
5: u'其他部',
8: u'幼儿部'
}
dept_id = db.default.school_unit_class.create(
school_id=school_id,
unit_type=1,
unit_name=type_dict[school.type],
level_id=1,
type=school.type,
learn_length=school.learn_length,
)
path = "|%s" % dept_id
db.default.school_unit_class.filter(id=dept_id).update(path=path)
dept = db.slave.school_unit_class.wait(id=dept_id)
depts = [dept] if dept else []
out = [
Struct({
"id": d.id,
"name": d.unit_name,
"type": d.type,
"learn_length": d.learn_length,
"max_class": 30
}) for d in depts
]
return out
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_unit_students(user, unit_id):
"""
获取班级学生信息(不带学科)
----------------------
王晨光 2017-2-19
----------------------
:param unit_id: 班级ID
:return: [{'user_id':学生ID, 'user_name':姓名, 'phone_number':电话,
'sex':1男2女, 'is_status':0非暂存1表示暂存, 'abb':拼音缩写}]
*结果按姓名排序
"""
if not unit_id:
return []
# 获取bind_ids
user_ids = cache.unit_students.get(unit_id)
if not user_ids:
user_ids = user.get_mobile_order_region().filter(
unit_class_id=unit_id,
user_type=1).select('user_id').flat('user_id')[:]
user_ids = list(set(user_ids))
cache.unit_students.set(unit_id, user_ids)
# 合并结果
students = []
userd = com_user.get_users(user_ids)
for user_id in user_ids:
u = userd.get(user_id)
if u:
student = {
'user_id': u.id,
'bind_id': u.id,
'user_name': u.real_name,
'phone_number': u.phone,
'sex': u.sex,
'is_status': 0,
'abb': pinyin_abb(u.real_name),
'portrait': u.portrait,
}
student = Struct(student)
students.append(student)
students.sort(key=lambda x: x.abb)
return students
def users_info_temp(user_ids):
"""
获取用户姓名头像边框
:param user_ids:批量获取用户信息id
:return:
"""
sql = """
select a.id, a.real_name, p.portrait from auth_user a, auth_profile p
where a.id = p.user_id and user_id in (%s)
""" % join(user_ids)
user_info = db.tbkt_user.fetchall_dict(sql)
user_map = {i.id: i for i in user_info}
user_ids = [i.id for i in user_info]
school_info = db.ketang.mobile_order_region.select(
'school_name', 'user_id', 'unit_class_id unit_id').filter(
user_id__in=user_ids).group_by('user_id')[:]
school_map = {i.user_id: i for i in school_info}
unit_ids = [i.unit_id for i in school_info]
unit_names = db.default.school_unit_class.filter(id__in=unit_ids).select(
"unit_name", "id")[:]
unit_map = {i.id: i.unit_name for i in unit_names}
user_borders = db.default.user_border_detail.filter(user_id__in=user_ids,
status=1)[:]
border_map = {i.user_id: i.border_id for i in user_borders}
users = []
for i in user_info:
user = user_map.get(i.id)
region = school_map.get(i.id, Struct())
border_id = border_map.get(i.id, 0)
border_url = ""
if border_id != 0:
border_info = db.default.border.get(id=border_id)
if border_info:
border_url = border_info.border_url
if not region:
continue
users.append(
dict(user_id=i["id"],
real_name=user.real_name,
portrait=math_com.get_portrait(user.portrait, 1),
school_name=region.school_name,
unit_name=unit_map.get(region.unit_id),
border_url=get_absurl(border_url)))
out = {i["user_id"]: i for i in users}
return out
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 get_user(request, user_id):
"""
成功返回User对象
失败返回None
王晨光 2016-12-22
"""
data = cache.user_profile.get(user_id)
if not data:
url = '/account/profile'
hub = tbktapi.Hub(request)
r = hub.com.post(url)
if r['response'] == 'fail':
return
data = Struct(r['data'])
cache.user_profile.set(user_id, data)
user = User(data, request)
return user
def user_index(user_id):
"""
正式第一周 rc测试
"""
# c = config() # 读取测试环境配置信息， rc环境替换为程序配置
grade_id = user_grade(user_id)
out = Struct()
out.know_status = -1 # 知识训练场
out.wrong_status = -1 # 高频错题
out.pk_status = -1 # 每周竞技
out.month_status = -1 # 每月竞技
out.is_open = 0 # 是否在开放日期里
out.once_open = 1 # 往期回顾是否开放
out.once_week = []
out.id = 0
week_day = datetime.date.today().weekday()
week_info = db.tbkt_active.full_score_week_list.select(
"id", "name", "begin_time", "end_time").order_by("begin_time")
b_time, e_time = time_stamp()
for i in week_info:
if b_time <= i.begin_time < e_time:
# 如果开始在本周之内，则算是本周课程
out.name = i.name
out.id = i.id
i.open_time = i.begin_time + 9 * 3600
out.open_time = time.strftime("%m月%d日 %H点",
time.localtime(i.open_time))
out.chance_over = pk_num(user_id, i.id).have_chance
if week_day in (5, 6):
# 在开课天里，返回状态关闭往期回顾
out.once_open = 1
if int(time.time()) >= i.open_time:
# 达到开课时间点
out.is_open = 1
out.once_open = 0
out.know_status, out.wrong_status, out.pk_status = user_knowledge_info(
user_id, i.id, grade_id)
if out.pk_status == 1 and out.chance_over > 0:
out.pk_status = 0
if i.begin_time < b_time:
# 如果开始时间小于本周开始时间，则算是往期课程
out.once_week.append(dict(id=i.id, name=i.name))
out.once_week = sorted(out.once_week, key=lambda x: (-x["id"]))
return out
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 pk_submit(user_id, week_id, info, score, user_city):
"""
每周竞技提交
:param user_id: 用户id
:param week_id: 课程id
:param info: 提交数据
:param score: 成绩
:param user_city: 用户城市id
:return:
"""
grade_id = user_grade(user_id)
have_chance = pk_num(user_id, week_id).have_chance
if have_chance <= 0:
return {}
score = score if score > 0 else 0
nowt = int(time.time())
pk_info = db.tbkt_active.full_score_test.get(type=3,
user_id=user_id,
week_id=week_id,
grade_id=grade_id,
status=1)
out = Struct()
out.pk_status = 1 if score else 0
out.score = score
if pk_info and pk_info.score >= score:
out.max_score = pk_info.score
out.pk_status = 0
else:
out.max_score = score
with db.tbkt_active as active:
active.full_score_test.create(user_id=user_id,
grade_id=user_grade(user_id),
week_id=week_id,
type=3,
city=user_city,
text=json.dumps(info),
status=1,
score=score,
add_time=nowt)
out.rank = pk_result(user_id, week_id, user_city) # 结果页数据返回排行
out.num = pk_num(user_id, week_id).have_chance # 用户剩余pk次数
return 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 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 _probability(self, sort, default_award=None, once=1):
"""
中奖概率
:param 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: 重复中奖/超出日发奖范围/超出总数 后 改为中奖默认值，
:return:
"""
if not sort:
raise ValueError("lack Value: sort!", sort)
if not default_award:
raise ValueError("lack Value: default_award!", default_award)
dice = random.random()
begin = 0
award = []
for s in sort:
if begin < dice <= begin + s['rate'] and s['status'] == 1:
award = s
break
else:
begin += s['rate']
if not award:
award = default_award
award_type = award['award_type']
if award != default_award:
# 判断总量是否发完：
if int(award['total']) != -1 and self.all_award_num(
award_type) >= int(award['total']):
award = default_award
# 判断单日奖品是否发完:
if int(award['day_num']) != -1 and self.day_award_num(
award_type) >= int(award['day_num']):
award = default_award
# 判断用户是否已经抽过奖:
if once:
if self.user_award_num(award_type) >= 1:
award = default_award
return Struct(award)
def base_option(options):
"""
选项基础数据
:param options:
:return:
"""
if not options:
return []
option = []
for i in options:
d = Struct()
d.id = i.id
d.content = i.content
d.image = get_absurl(i.image)
d.is_right = i.is_right
d.option = i.option
d.ask_id = i.question_id
d.link_id = i.link_id
option.append(d)
return option
def parse_parse(parse):
"""文字解析
:returns: [{'content':内容, 'image':{'url':图片地址, 'align':''}}]
"""
if not parse:
return [{"content": "", "image": {"url": ""}}]
object_list = json.loads(parse) if parse else []
new_object_list = []
for obj in object_list:
obj["content"] = replace_symbol(obj.get("content", ''))
images = obj.get('images', [])
if images:
image = images[0]
image['url'] = format_url(image['url'])
else:
image = {}
obj['image'] = image
obj = Struct(obj)
new_object_list.append(obj)
return new_object_list
def r_user_info(request):
"""
@api /huodong/full/class/user [满分课堂] 用户教材
@apiGroup full_class
@apiSuccessExample {json} 成功返回
{
"message": "",
"next": "",
"data": {
"school_name": "郑州市第七十中学105班",
"book_name": "人教版一年级下册"
},
"response": "ok",
"error": ""
}
"""
user = request.user
out = Struct()
out.book_name = common.get_user_book_name(user)
unit = user.unit
out.school_name = "%s%s" % (unit.school_name, unit.name) if unit else "--"
return ajax.jsonp_ok(request, out)
def all_award_detail(self, p=1):
"""分页返回全部获奖用户"""
begin = int((p - 1) * 10)
sql = """
select (@rowNum:=@rowNum+1) as num ,a.user_name ,a.award_name, a.user_id,a.award_type from active_award a ,
(select (@rowNum :=%s)) z
where a.active_id=%s and award_name<>'谢谢参与' order by a.award_type ,a.id DESC limit %s ,%s
""" % (begin, self.active_id, begin, 10)
detail = db.tbkt_active.fetchall_dict(sql)
if not detail:
return [], 0
user_ids = list(set([a.user_id for a in detail]))
user_info = com_user.users_info(user_ids)
gift = db.tbkt_active.active_score_gift.filter(
active_id=self.active_id, active_type=1,
del_state=0).select('img_url', 'sequence award_type')[:]
gift_url = {int(i.award_type): i.img_url for i in gift}
award_detail = []
for d in detail:
img_url = format_url(gift_url.get(int(d.award_type) or ''))
awd = Struct(time=time.strftime("%Y-%m-%d %H:%M:%S",
time.localtime(
d.add_time)).decode('utf-8'),
name=d.award_name,
url=img_url,
award_type=d.award_type)
info = user_info.get(d.user_id)
if info:
awd.update(info)
award_detail.append(awd)
rank = sorted(award_detail, key=lambda x: x.num)
sql = """
select count(1) num from active_award a where active_id=%s and award_name<>'谢谢参与' and remark='%s'
""" % (self.active_id, self.app_id)
total = db.tbkt_active.fetchone_dict(sql)
return rank, total.num
def get_unit_students(request, unit_id):
"""
获取班级学生信息
:param request:
:param unit_id:
:return:
"""
url = '/class/students'
args = dict(unit_id=unit_id)
hub = tbktapi.Hub(request)
r = hub.com.post(url, args)
out = []
if r.response == 'ok':
stu = map(Struct, r.data.get('students'))
for i in stu:
info = Struct()
info.phone = i.phone_number
info.id = int(i.user_id)
info.is_open = 1 if i.status in (2, 9) else 0
info.user_name = i.user_name
info.portrait = i.portrait # i.units
out.append(info)
return out
def _get_question(question_ids):
"""
get question
:param question_ids:
:return:
"""
if not isinstance(question_ids, (list, tuple)):
return []
questions = db.tbkt_yw.yw_question.select(
"content", "video", "image", "type", "show_parse", "category", "id",
"article_text").filter(id__in=question_ids)[:]
if not questions:
return []
out = []
ask_map = get_ask(question_ids)
for k, i in enumerate(questions):
d = Struct()
d.article_title = ""
d.article_text = ""
d.content = ""
if i.type == 8:
# 阅读理解
d.article_title = format_content(i.content)
d.article_text = i.article_text
else:
# 不是阅读理解
d.content = i.content
d.video = get_absurl(i.video).replace("//", "/")
d.image = get_absurl(i.image).replace("//", "/")
d.type = i.type
d.category = i.category
d.no = num_to_ch(k + 1)
d.num = k + 1
d.asks = ask_map.get(i.id, [])
d.id = i.id
out.append(d)
return out
def post(self, path, data=None, json=None, **kwargs):
"""Sends a POST request.
:param path: 接口路径(比如 "/account/profile")
:param data: (optional) Dictionary, bytes, or file-like object to send in the body.
:param json: (optional) json data to send in the body.
:param kwargs: 可选参数, 比如timeout, cookies, headers...
:return: 成功返回同步课堂ajax格式的字典, 比如:
{
"message": "",
"next": "",
"data": {},
"response": "ok",
"error": ""
}
失败返回None
"""
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.post(url, data, json, **kwargs)
if r.status_code != 200:
logging.warning('tbktapi.post %s' % r.status_code)
return
return Struct(r.json())
def get_paper_number(paper_id):
"""
根据试卷ID返回 题目标题
:param paper_id: 试卷ID
:return: {ask_id:{'q_num': 大题号, 'a_num': 小题号}}
"""
paper_type = db.ziyuan_slave.sx2_paper_question_number.select(
"object_id").filter(paper_id=paper_id, type=1).flat("object_id")[:]
sql = """
select a.id ask_id, a.question_id, d.paper_type_id from
sx2_paper_question_number n inner join sx2_paper_detail d on n.paper_id = %s
and n.paper_id = d.paper_id and n.type = 2 and n.object_id = d.question_id
inner join sx2_question_ask a on a.question_id = d.question_id
""" % paper_id
papers = db.ziyuan_slave.fetchall_dict(sql)
if not papers:
return {}
out = {}
n = 0 # 初始化小题号
for k, p in enumerate(paper_type):
q_num = num_to_ch(k + 1)
for a in papers:
if a.paper_type_id == p:
r = len([i for i in papers if i.paper_type_id == p])
n += 1
# 题号 (1)
a_num = u"(%s)" % n # if r > 1 else ''
out[int(a.ask_id)] = Struct(q_num=q_num, a_num=a_num)
# 题目ID
else:
# 重新赋值 避免返回整张试卷问题
n = 0
return out
def yw_paper_list(user, subject_id):
"""
语文试卷列表
:param user:
:param subject_id:
:return:
"""
from apps.terminal2018.common import p_yw_user_book
book_info = p_yw_user_book(user.id)
if not book_info:
return []
book_id = book_info.id
paper_ids = BOOK_PAPER.get(book_id)
if not paper_ids:
return []
sql = """
select t.object_id, count(DISTINCT unit_class_id) num
from yw_task_new t, yw_task_class_new c
where t.id = c.task_id and t.type = %s and t.add_user = %s and c.status > -1
and t.object_id in %s and c.unit_class_id in (%s) group by t.object_id
""" % (YW_TASK_TYPE, user.id, str(paper_ids), ",".join(
str(i.id) for i in user.units))
data = db.tbkt_yuwen.fetchall_dict(sql)
unit_num = len(user.units) if user.units else 0
paper_map = {i.object_id: i.num for i in data}
out = []
for i in paper_ids:
d = Struct()
name = PAPER.get(i)
d.id = i
d.name = name
send_num = paper_map.get(i, 0)
d.status = 1 if send_num >= unit_num else 0
out.append(d)
return out
def check_wrong_info(task_id, stu_ids, question_ids):
"""
作业错误率以小题为主
:param task_id: 作业id
:param stu_ids: 学生id
:param question_ids: 题目id list
:return:
"""
stu_test = db.tbkt_yuwen.yw_test_detail_new.select(
"user_id", "text").filter(task_id=task_id,
user_id__in=stu_ids,
status=1)[:]
total = len(stu_test)
wrong_ask = []
for i in stu_test:
txt = json.loads(i.text)
for t in txt:
if t["result"] == 0:
wrong_ask.append(t["ask_id"])
result_map = Counter(wrong_ask)
asks = db.tbkt_yw.yw_question_ask.select(
"id", "question_id").filter(question_id__in=question_ids)
q_map = OrderedDict()
for i in asks:
q_map.setdefault(i.question_id, []).append(i.id)
wrong_info = []
for i, qid in enumerate(q_map, start=1):
asks = q_map.get(qid)
for j, ask_id in enumerate(asks, start=1):
d = Struct()
d.no = i if len(asks) == 1 else "%s(%s)" % (i, j)
d.rate = result_map.get(ask_id, 0) / total * 100 if total else 0
d.ask_id = ask_id
wrong_info.append(d)
return wrong_info