async def get(self, subject_id):
match = MatchStage({'_id': ObjectId(subject_id)})
lookup_option = LookupStage(SubjectOption, 'cid', 'subject_cid')
lookup_files = LookupStage(UploadFiles, 'image_cid', 'cid')
subject_list = await Subject.aggregate([match, lookup_option, lookup_files]).to_list(None)
subject = {}
option_fir_doc = {}
option_sec_doc = {}
option_thr_doc = {}
option_fur_doc = {}
file_doc = {}
if subject_list:
subject = subject_list[0]
option_list = subject.subject_option_list
file_list = subject.upload_files_list
if file_list:
file_doc = file_list[0]
subject_dimension_list = await SubjectDimension.find(
dict(status=STATUS_SUBJECT_DIMENSION_ACTIVE, parent_cid=None)).to_list(None)
for subject_dimension in subject_dimension_list:
sub_subject_dimension = await SubjectDimension.find(
dict(status=STATUS_SUBJECT_DIMENSION_ACTIVE, parent_cid=subject_dimension.cid)).to_list(None)
subject_dimension.sub_subject_dimension_list = []
if sub_subject_dimension:
subject_dimension.sub_subject_dimension_list = sub_subject_dimension
return locals()
async def get_wrong_question(self, member_id, question_ids):
"""
:param member_id:
:param question_id:
:return:
"""
stage_list = [
MatchStage({'cid': {'$in': question_ids}}),
LookupStage(SubjectOption, let={'cid': '$cid'},
pipeline=[{'$match': {'$expr': {'$and': [{'$eq': ['$subject_cid', '$$cid']}]}}},
SortStage([('code', ASC)])], as_list_name='options'),
LookupStage(MemberWrongSubject, let={'cid': '$cid'}, as_list_name='wrong_subjects', pipeline=[
{'$match': {
'$expr': {'$and': [{'$eq': ['$subject_cid', '$$cid']}, {'$eq': ['$member_cid', member_id]}]}}}
]),
LookupStage(UploadFiles, 'image_cid', 'cid', 'file_list'),
]
subjects = await Subject.aggregate(
stage_list=stage_list).to_list(None)
if not subjects:
return None
questions = list()
for subject in subjects:
question = dict()
question['id'] = subject.cid
question['title'] = subject.title
question['resolving'] = subject.resolving
options = []
for opt in subject.options:
option = {'id': opt.cid, 'title': opt.title, 'true_answer': opt.correct, }
if subject.wrong_subjects[-1].option_cid == opt.cid:
option['show_false'] = 'option_false'
else:
option['show_false'] = ''
options.append(option)
question['option_list'] = options
question['category_name'] = CATEGORY_SUBJECT_KNOWLEDGE_DICT.get(subject.category)
question['knowledge_first'] = KNOWLEDGE_FIRST_LEVEL_DICT.get(subject.knowledge_first)
question['knowledge_second'] = KNOWLEDGE_FIRST_LEVEL_DICT.get(subject.knowledge_second)
question['difficulty'] = subject.difficulty
question['correct_percent'] = await self.get_correct_percent(subject.cid)
title_picture = subject.file_list[0].title if subject.file_list else ''
if title_picture:
title_picture_url = '%s://%s%s%s%s' % (SERVER_PROTOCOL, SERVER_HOST, STATIC_URL_PREFIX, 'files/',
title_picture)
else:
title_picture_url = ''
question['picture_url'] = title_picture_url
questions.append(question)
return questions
def do_merge_city_stat_member_quantity(province_dict: dict, choice_time, city_code_list=None):
"""
合并省份统计信息
:param province_dict:
:param city_code_list
:param choice_time
:return:
"""
query_dict = {}
if province_dict:
query_dict['province_code'] = {'$in': [code for code in province_dict.keys()]}
if city_code_list:
query_dict['city_code'] = {'$in': city_code_list}
else:
query_dict['city_code'] = {'$ne': None}
if not choice_time:
# 取前一天凌晨12点之前的数据
yesterday = get_yesterday()
query_dict['updated_dt'] = {'$lt': yesterday}
else:
# 当天下一天凌晨的时候
max_choice_time = choice_time.replace(hour=23, minute=59, second=59, microsecond=999)
query_dict['updated_dt'] = {'$gte': choice_time, '$lt': max_choice_time}
query_dict['status'] = STATUS_USER_ACTIVE
match_stage = MatchStage(query_dict)
group_stage = GroupStage('city_code', quantity={'$sum': 1}, province_code={'$first': '$province_code'})
sort_stage = SortStage([('quantity', DESC)])
p_lookup_stage = LookupStage(AdministrativeDivision, 'province_code', 'post_code', 'province_list')
c_lookup_stage = LookupStage(AdministrativeDivision, '_id', 'post_code', 'city_list')
city_cursor = Member.sync_aggregate([match_stage, group_stage, sort_stage, p_lookup_stage, c_lookup_stage])
t_province_dict = {}
t_province_dict = get_merge_city_data(city_cursor, province_dict, t_province_dict)
if t_province_dict:
province_dict.update(t_province_dict)
async def get(self):
race_cid = self.get_argument('race_cid', '')
menu_list = await get_menu(self, 'config', race_cid)
title = self.get_argument('title', '')
code = self.get_argument('code', '')
query_params = {'race_cid': race_cid}
if title:
query_params['title'] = {'$regex': title, '$options': 'i'}
code = self.get_argument('code', '')
if code:
query_params['code'] = {'$regex': code, '$options': 'i'}
per_page_quantity = int(self.get_argument('per_page_quantity', 10))
to_page_num = int(self.get_argument('page', 1))
page_url = '%s?page=$page&per_page_quantity=%s&code=%s&title=%s' % (
self.reverse_url("backoffice_race_redpkt_rule_list"),
per_page_quantity, code, title)
paging = Paging(page_url,
RedPacketRule,
current_page=to_page_num,
items_per_page=per_page_quantity,
left_pipeline_stages=[
LookupStage(RedPacketItemSetting, 'cid',
'rule_cid', 'lottery_setting'),
LookupStage(RedPacketConf, 'cid', 'rule_cid',
'redpacket_conf')
],
sort=['-updated_dt'],
**query_params)
await paging.pager()
return locals()
def do_merge_city_stat_member_time(province_dict: dict, city_code_list=None):
"""
合并省份统计信息
:param province_dict:
:param city_code_list
:return:
"""
query_dict = {}
if province_dict:
query_dict['province_code'] = {'$in': [code for code in province_dict.keys()]}
if city_code_list:
query_dict['city_code'] = {'$in': city_code_list}
else:
query_dict['city_code'] = {'$ne': None}
# 取前一天凌晨12点之前的数据
time_match = get_yesterday()
query_dict['updated_dt'] = {'$lt': time_match}
match_stage = MatchStage(query_dict)
group_stage = GroupStage('city_code', quantity={'$sum': '$learn_times'},
province_code={'$first': '$province_code'})
sort_stage = SortStage([('quantity', DESC)])
p_lookup_stage = LookupStage(AdministrativeDivision, 'province_code', 'post_code', 'province_list')
c_lookup_stage = LookupStage(AdministrativeDivision, '_id', 'post_code', 'city_list')
city_cursor = MemberLearningDayStatistics.sync_aggregate(
[match_stage, group_stage, sort_stage, p_lookup_stage, c_lookup_stage])
t_province_dict = {}
t_province_dict = get_merge_city_data(city_cursor, province_dict, t_province_dict)
if t_province_dict:
province_dict.update(t_province_dict)
async def get(self, subject_id):
race_cid = self.get_argument('race_cid', '')
if race_cid:
menu_list = await get_menu(self, 'config', race_cid)
match = MatchStage({'cid': subject_id})
lookup_option = LookupStage(SubjectOption, 'cid', 'subject_cid')
lookup_files = LookupStage(UploadFiles, 'image_cid', 'cid')
subject_list = await Subject.aggregate([match, lookup_option, lookup_files]).to_list(None)
subject = {}
option_fir_doc = {}
option_sec_doc = {}
option_thr_doc = {}
option_fur_doc = {}
file_doc = {}
if subject_list:
subject = subject_list[0]
difficulty = subject.difficulty
category = subject.category
option_list = subject.subject_option_list
file_list = subject.upload_files_list
if file_list:
file_doc = file_list[0]
return locals()
def write_sheet_race_member_information(race_cid: str, post_code):
"""
导出该活动下面得会员信息，主要是手机号码
:param race_cid:
:param post_code
:return: excel
"""
workbook = xlsxwriter.Workbook('黄山市会员信息统计.xlsx')
sheet = workbook.add_worksheet('黄山市会员信息')
sheet.merge_range(0, 0, 0, 1, '昵称')
sheet.write_string(0, 2, '地区')
sheet.merge_range(0, 3, 0, 4, '手机号码')
lookup_stage = LookupStage(Member, 'member_cid', 'cid', 'member_list')
district_lookup_stage = LookupStage(AdministrativeDivision,
'district_code', 'post_code',
'district_list')
match_stage = MatchStage({
'race_cid': race_cid,
'record_flag': 1,
'city_code': post_code
})
# 该市下面所有得区
district_title_list = AdministrativeDivision.sync_distinct(
'title', {'parent_code': post_code})
race_mapping_cursor = RaceMapping.sync_aggregate(
[match_stage, lookup_stage, district_lookup_stage])
data_center_format = workbook.add_format({
'valign': 'vcenter',
'align': 'center',
'font_name': 'Microsoft YaHei',
'border': 1
})
num = 1
while True:
try:
race_mapping = race_mapping_cursor.next()
if race_mapping:
if race_mapping.member_list and race_mapping.district_list:
member = race_mapping.member_list[0]
district = race_mapping.district_list[0]
if district.title in district_title_list:
sheet.merge_range(num, 0, num, 1, member.nick_name,
data_center_format)
sheet.write_string(num, 2, district.title,
data_center_format)
sheet.merge_range(num, 3, num, 4,
str(race_mapping.mobile),
data_center_format)
num += 1
else:
continue
except StopIteration:
break
workbook.close()
async def get(self):
race_cid = self.get_argument('race_cid', '')
menu_list = await get_menu(self, 'config', race_cid)
if race_cid:
r_look_stage = LookupStage(RaceSubjectRefer, 'cid', 'subject_cid', 'race_subject_list')
# 已经引用过的题目,在引用页面中不展示
race_refer_cid_list = await RaceSubjectRefer.distinct('subject_cid', filtered={'race_cid': race_cid})
query_params = {'cid': {'$nin': race_refer_cid_list}}
kw_name = self.get_argument('kw_name', '')
kw_difficulty = self.get_argument('kw_difficulty', '')
category_use = self.get_argument('category_use', '')
query_params['status'] = STATUS_SUBJECT_ACTIVE
if kw_name:
query_params['$or'] = [
{"custom_code": {'$regex': kw_name, '$options': 'i'}},
{"title": {'$regex': kw_name, '$options': 'i'}},
{"code": {'$regex': kw_name, '$options': 'i'}}
]
if kw_difficulty:
query_params['difficulty'] = int(kw_difficulty)
if category_use:
query_params['category'] = int(category_use)
# 分页 START
per_page_quantity = int(self.get_argument('per_page_quantity', 10))
to_page_num = int(self.get_argument('page', 1))
page_url = '%s?page=$page&per_page_quantity=%s&race_cid=%s&kw_name=%s&kw_difficulty=%s&category_use=%s' % (
self.reverse_url("backoffice_race_subject_refer_list"), per_page_quantity, race_cid, kw_name,
kw_difficulty, category_use)
paging = Paging(page_url, Subject, current_page=to_page_num,
items_per_page=per_page_quantity,
sort=['custom_code'], **query_params)
await paging.pager()
# 分页 END
return locals()
async def post(self):
res = {'code': 1}
pageNum = int(self.get_argument('pageNum', 1))
size = int(self.get_argument('size', 10))
skip = (pageNum - 1) * size if (pageNum - 1) * size > 0 else 0
filter_dict = {'member_cid': self.current_user.cid, 'record_flag': 1}
match = MatchStage(filter_dict)
lookup = LookupStage(Present,
local_field='present_cid',
foreign_field='cid',
as_list_name='present')
skip = SkipStage(skip)
sort = SortStage([('updated_dt', DESC)])
limit = LimitStage(int(size))
coupon_list = await DiscountCoupon.aggregate(
[match, lookup, skip, sort, limit]).to_list(None)
if coupon_list:
html = self.render_string('wechat/integral/coupon_data_list.html',
coupon_list=coupon_list)
else:
html = ''
res['html'] = html
res['current_length'] = len(coupon_list)
res['totalSize'] = await DiscountCoupon.count(filter_dict)
return res
def get_choice_dimension_list(race_choice_rule: RaceSubjectChoiceRules):
"""
获取规则维度信息
:param choice_rule:
:return:
"""
result_list = []
try:
if race_choice_rule and race_choice_rule.dimension_rules:
dimension_cid_list = list(race_choice_rule.dimension_rules.keys())
if dimension_cid_list:
match_stage = MatchStage({
'cid': {
'$in': dimension_cid_list
},
'parent_cid': None
})
lookup_stage = LookupStage(SubjectDimension, 'cid',
'parent_cid', 'dimension_list')
subject_dimension_list = SubjectDimension.sync_aggregate(
[match_stage, lookup_stage]).to_list(None)
for subject_dimension in subject_dimension_list:
# 获取抽样条件
dimension_rule = get_sampling_condition(
subject_dimension,
race_choice_rule.dimension_rules.get(
subject_dimension.cid), race_choice_rule.quantity)
if dimension_rule:
result_list.append(dimension_rule)
except Exception:
logger.error(traceback.format_exc())
return result_list
async def get(self):
race_cid = self.get_argument('race_cid', '')
menu_list = await get_menu(self, 'config', race_cid)
if race_cid:
query_params = {'record_flag': 1, 'race_cid': race_cid}
index = self.get_argument('index', '')
refer_index = index # index在前端可能是个关键字,模板语言解析不了
if index:
query_params['$or'] = [{"index": int(index)}]
r_look_stage = LookupStage(RaceSubjectChoiceRules, 'rule_cid',
'cid', 'rule_list')
# 分页 START
per_page_quantity = int(self.get_argument('per_page_quantity', 10))
to_page_num = int(self.get_argument('page', 1))
page_url = '%s?race_cid=%s&page=$page&per_page_quantity=%s&index=%s' % (
self.reverse_url("backoffice_race_game_checkpoint_list"),
race_cid, per_page_quantity, index)
paging = Paging(page_url,
RaceGameCheckPoint,
pipeline_stages=[r_look_stage],
current_page=to_page_num,
items_per_page=per_page_quantity,
sort=['index'],
**query_params)
await paging.pager()
# 分页 END
return locals()
async def get(self):
show_export_btn = PERMISSION_TYPE_REPORT_SUBJECT_ANALYZE_EXPORT in self.current_user.permission_code_list
s_province = self.get_argument('province', '')
s_city = self.get_argument('city', '')
s_age_group = self.get_argument('age_group', '')
s_gender = self.get_argument('gender', '')
s_education = self.get_argument('education', '')
sort = int(self.get_argument('sort', 1))
per_page_quantity = int(self.get_argument('per_page_quantity', 50))
to_page_num = int(self.get_argument('page', 1))
# 行政信息
json_ad = json.dumps(await get_administrative_division(), ensure_ascii=False)
subject_dimension_list = await SubjectDimension.aggregate([
MatchStage({'parent_cid': None}),
SortStage([('ordered', ASC)]),
LookupStage(SubjectDimension, 'cid', 'parent_cid', 'sub_list')
]).to_list(None)
dimension_dict = {}
for dimension in subject_dimension_list:
t_dimension = self.get_argument(dimension.cid, '')
if t_dimension:
dimension_dict['%s' % dimension.cid] = t_dimension
return locals()
async def get(self):
race_cid = self.get_argument('race_cid', '')
menu_list = await get_menu(self, 'report', race_cid, tag=1)
region_code_list = []
manage_region_code_list = self.current_user.manage_region_code_list
ad_cursor = AdministrativeDivision.find(
{'code': {
'$in': self.current_user.manage_region_code_list
}})
while await ad_cursor.fetch_next:
ad = ad_cursor.next_object()
if ad:
if ad.level == 'P':
region_code_list.append('[p]%s' % ad.code)
elif ad.level == 'C':
region_code_list.append('[c]%s' % ad.code)
elif ad.level == 'D':
region_code_list.append('[d]%s' % ad.code)
subject_dimension_list = await SubjectDimension.aggregate([
MatchStage(
dict(status=STATUS_SUBJECT_DIMENSION_ACTIVE, parent_cid=None)),
LookupStage(SubjectDimension, 'cid', 'parent_cid',
'sub_subject_dimension_list')
]).to_list(None)
return locals()
async def post(self):
r_dict = {'code': 0}
category = self.get_i_argument('category', None)
if not category or (int(category) not in [CATEGORY_SUBJECT_BENCHMARK, CATEGORY_SUBJECT_GRADUATION]):
return r_dict
try:
stage_list = [
MatchStage({'category_use': int(category), 'status': STATUS_SUBJECT_ACTIVE}),
LookupStage(SubjectOption, let={'cid': '$cid'},
pipeline=[{'$match': {'$expr': {'$and': [{'$eq': ['$subject_cid', '$$cid']}]}}},
SortStage([('code', ASC)])], as_list_name='option_list'),
LookupStage(UploadFiles, 'image_cid', 'cid', 'image_list'),
SortStage([('code', ASC)])
]
subjects = await Subject.aggregate(stage_list=stage_list).to_list(None)
question_list = []
for sbj in subjects:
picture_url = ''
if sbj.image_list:
picture_url = '%s://%s%s%s%s' % (
SERVER_PROTOCOL, SERVER_HOST, STATIC_URL_PREFIX, 'files/', sbj.image_list[0].title)
question = {'id': sbj.cid,
'title': sbj.title,
'picture_url': picture_url,
'category_name': CATEGORY_SUBJECT_KNOWLEDGE_DICT.get(sbj.category, ''),
'difficulty_degree': "%s/5" % sbj.difficulty,
'knowledge_first': KNOWLEDGE_FIRST_LEVEL_DICT.get(sbj.knowledge_first, ''),
'knowledge_second': KNOWLEDGE_SECOND_LEVEL_DICT.get(sbj.knowledge_second, ''),
'resolving': sbj.resolving,
'option_list': [{
'id': opt.cid, 'title': opt.title, 'true_answer': opt.correct
} for opt in sbj.option_list]}
question_list.append(question)
r_dict = {
'code': 1000,
'question_list': question_list
}
except Exception:
logger.error(traceback.format_exc())
return r_dict
def do_statistics_member_quantity(cache_key, city_code_list, choice_time):
"""开始统计
:param cache_key:
:param city_code_list:
:param choice_time
:return:
"""
RedisCache.set(cache_key, KEY_CACHE_REPORT_DOING_NOW, 5 * 60)
stage_list = []
if city_code_list:
stage_list.append(MatchStage({'city_code': {'$in': city_code_list}}))
if not choice_time:
# 取前一天凌晨12点之前的数据
yesterday_time = get_yesterday()
time_match = MatchStage({'updated_dt': {'$lt': yesterday_time}})
else:
# 当天下一天凌晨的时候
max_choice_time = choice_time.replace(hour=23, minute=59, second=59, microsecond=999)
time_match = MatchStage({'updated_dt': {'$gte': choice_time, '$lt': max_choice_time}})
stage_list.append(time_match)
stage_list.append(MatchStage({'status': STATUS_USER_ACTIVE}))
group_stage = GroupStage('province_code', quantity={'$sum': 1})
lookup_stage = LookupStage(AdministrativeDivision, '_id', 'post_code', 'ad_list')
sort_stage = SortStage([('quantity', DESC)])
stage_list += [group_stage, lookup_stage, sort_stage]
province_cursor = Member.sync_aggregate(stage_list)
province_dict = {}
while True:
try:
province_stat = province_cursor.next()
if province_stat:
province_code = province_stat.id if province_stat.id else '000000'
quantity = province_stat.quantity
title = 'undefined'
ad_list = province_stat.ad_list
if ad_list:
ad: FacadeO = ad_list[0]
if ad:
title = ad.title.replace('省', '').replace('市', '')
province_dict[province_code] = {
'code': province_code,
'title': title,
'data': quantity
}
except StopIteration:
break
# 合并城市统计信息
do_merge_city_stat_member_quantity(province_dict, choice_time, city_code_list)
data = [v for v in province_dict.values()]
if not data:
early_warning_empty("start_statistics_member_quantity", cache_key, city_code_list, '学习近况中人数数据为空，请检查！')
RedisCache.set(cache_key, msgpack.packb(data))
async def get(self, dan_grade_id):
match = MatchStage({'_id': ObjectId(dan_grade_id)})
lookup_files = LookupStage(UploadFiles, 'thumbnail', 'cid')
lookup_rules = LookupStage(SubjectChoiceRules, 'rule_cid', 'cid')
dan_grade_list = await GameDanGrade.aggregate(
[match, lookup_files, lookup_rules]).to_list(None)
subject_choice_rules_list = await SubjectChoiceRules.find(
dict(status=STATUS_SUBJECT_CHOICE_RULE_ACTIVE)).to_list(None)
dan_grade = None
file_doc = None
choice_rule = None
if dan_grade_list:
dan_grade = dan_grade_list[0]
file_list = dan_grade.upload_files_list
if file_list:
file_doc = file_list[0]
if dan_grade.subject_choice_rules_list:
choice_rule = dan_grade.subject_choice_rules_list[0]
return locals()
async def post(self):
res = dict(code=1)
pageNum = int(self.get_argument('pageNum', 1))
size = int(self.get_argument('size', 9))
current_datetime = datetime.datetime.now()
member = await Member.get_by_id(self.current_user.oid)
vehicle_code = member.vehicle_code
filter_dict = {
'$and': [{
'vehicle_code': vehicle_code
}, {
'push_datetime': {
'$lte': current_datetime
}
}, {
'pull_types': {
'$in': [PUSH_RECEIVE_WECHAT]
}
}, {
'status': {
'$in': [
STATUS_PULL_ACTION_PUSHED,
STATUS_PULL_ACTION_PUSHED_SUCCESS
]
}
}]
}
skip = (pageNum - 1) * size if (pageNum - 1) * size > 0 else 0
push_list = await SurveyPushAction.aggregate([
MatchStage(filter_dict),
LookupStage(Questionnaire,
local_field='q_cid',
foreign_field='cid',
as_list_name='questionnaire'),
SortStage([('push_datetime', DESC)]),
SkipStage(skip),
LimitStage(int(size))
]).to_list(int(size))
if push_list:
html = self.render_string(
'wechat/survey/questionnaire_history_data_list.html',
push_list=push_list)
else:
html = ''
res['html'] = html
res['current_length'] = len(push_list)
res['totalSize'] = await SurveyPushAction.count(filtered=filter_dict)
return res
def get_all_miss_history_box(race_cid):
"""
获取没有历史记录的红包游标
:param race_cid
:return:
"""
match_stage = MatchStage({'draw_status': 0})
if race_cid:
match_stage = MatchStage({'draw_status': 0, 'race_cid': race_cid})
cursor = RedPacketBox.sync_aggregate(stage_list=[
match_stage,
LookupStage(MemberCheckPointHistory,
as_list_name='history_list',
let={
'member_cid': '$member_cid',
'checkpoint': '$check_point_cid'
},
pipeline=[{
'$match': {
'$expr': {
'$and': [
{
'$eq': ['$member_cid', '$$member_cid']
},
{
'$eq':
['$checkpoint_cid', '$$checkpoint']
},
]
}
}
}]),
MatchStage({'history_list': []}),
])
index = 0
repair_list = []
while True:
try:
box = cursor.next()
repair_list.append('%s-%s-%s' %
(box.cid, box.member_cid, box.checkpoint_cid))
index += 1
except StopIteration:
break
with open('./repair-%s.json' % race_cid, 'w', encoding='utf-8') as f:
dist_list = json.dumps(list(repair_list), ensure_ascii=False)
f.write(dist_list)
return index
async def get(self, game_checkpoint_cid):
race_cid = self.get_argument('race_cid', '')
menu_list = await get_menu(self, 'config', race_cid)
if race_cid:
if game_checkpoint_cid:
match = MatchStage({
'race_cid': race_cid,
'cid': game_checkpoint_cid
})
lookup_rules = LookupStage(RaceSubjectChoiceRules, 'rule_cid',
'cid', 'subject_choice_rules_list')
lookup_red_rule = LookupStage(RedPacketRule, 'redpkt_rule_cid',
'cid', 'red_rule_list')
race_game_checkpoint_list = await RaceGameCheckPoint.aggregate(
[match, lookup_rules]).to_list(None)
# 关卡和红包规则关联在一起
race_red_rule_list = await RaceGameCheckPoint.aggregate(
[match, lookup_red_rule]).to_list(None)
race_subject_choice_rules_list = await RaceSubjectChoiceRules.find(
dict(race_cid=race_cid,
status=STATUS_SUBJECT_CHOICE_RULE_ACTIVE)
).to_list(None)
red_rule_list = await RedPacketRule.find(
dict(race_cid=race_cid,
record_flag=1,
status=STATUS_ACTIVE)).to_list(None)
game_checkpoint = None
choice_rule = None
if race_game_checkpoint_list:
game_checkpoint = race_game_checkpoint_list[0]
if game_checkpoint.subject_choice_rules_list:
choice_rule = game_checkpoint.subject_choice_rules_list[
0]
rule_cid = ''
if race_red_rule_list:
red_rule = race_red_rule_list[0]
if red_rule.red_rule_list:
rule_cid = red_rule.red_rule_list[0]
return locals()
def test3():
cursor = RaceMapping.sync_aggregate([
MatchStage(
{'race_cid': "CA755167DEA9AA89650D11C10FAA5413",
'member_cid':'9809FD6ED3F9534F87252A48018BE965','auth_address.province': {'$ne': None}, "record_flag": 1,}),
GroupStage({'member_cid': '$member_cid'}, race_list={'$push': '$$ROOT'}),
LookupStage(Member, '_id.member_cid', 'cid', 'member_list'),
MatchStage({'member_list': {'$ne': []}})
], allowDiskUse=True)
for race_member in cursor:
print(len(race_member.race_list))
for race in race_member.race_list:
print(race.cid,'---',race.mobile)
def do_stat_in_history(history_model, city_code_list, choice_time, ad_map={}):
"""
:param history_model:
:param city_code_list:
:param ad_map:
:param choice_time
:return:
"""
# 取前一天凌晨12点之前的数据
time_match = get_yesterday()
if not choice_time:
match_stage = MatchStage({'updated_dt': {'$lt': time_match}})
else:
# 当天下一天凌晨的时候
max_choice_time = choice_time.replace(hour=23, minute=59, second=59, microsecond=999)
match_stage = MatchStage({'updated_dt': {'$gte': choice_time, '$lt': max_choice_time}})
cursor = history_model.sync_aggregate([
match_stage,
GroupStage('member_cid', quantity={"$sum": 1}),
LookupStage(Member, '_id', 'cid', 'member_list'),
ProjectStage(**{
'province_code': {'$arrayElemAt': ['$member_list.province_code', 0]},
'city_code': {'$arrayElemAt': ['$member_list.city_code', 0]},
'quantity': '$quantity'
}),
MatchStage({'city_code': {'$in': city_code_list}}),
GroupStage('city_code', quantity={'$sum': "$quantity"}, province_code={'$first': '$province_code'}),
SortStage([('quantity', DESC)])
])
data = {}
while True:
try:
his = cursor.next()
city_data = data.get(his.province_code, {})
city = ad_map.get(his.id)
if not city:
city = AdministrativeDivision.sync_find_one({'code': his.id, 'parent_code': {'$ne': None}})
ad_map[city.code] = city
city_data[city.title] = his.quantity
data[his.province_code] = city_data
except StopIteration:
break
except Exception as e:
logger.error(str(e))
continue
return data, ad_map
def get_no_history_member():
"""
获取没有历史记录的用户
:return:
"""
data = Member.sync_aggregate([
MatchStage({'nick_name': '游客'}),
LookupStage(MemberCheckPointHistory, 'cid', 'member_cid',
'history_list'),
MatchStage({'history_list': []}),
GroupStage('cid')
]).to_list(None)
with open('./no-history-members.json', 'w', encoding='utf-8') as f:
dist_list = json.dumps(list([d.id for d in data]), ensure_ascii=False)
f.write(dist_list)
async def get(self):
h_lookup_stage = LookupStage(Subject, 'subject_cid', 'cid', 'subject_list')
race_cid = self.get_argument('race_cid', '')
menu_list = await get_menu(self, 'config', race_cid)
if race_cid:
query_params = {'race_cid': race_cid}
kw_name = self.get_argument('kw_name', '')
kw_difficulty = self.get_argument('kw_difficulty', '')
category_use = self.get_argument('category_use', '')
query_subject_params = {}
if kw_name:
query_subject_params['$or'] = [
{"custom_code": {'$regex': kw_name, '$options': 'i'}},
{"title": {'$regex': kw_name, '$options': 'i'}},
]
subject_cid_list = await Subject.distinct('cid', filtered=query_subject_params)
query_params['$and'] = [
{'subject_cid': {'$in': subject_cid_list}}
]
if kw_difficulty:
query_subject_params['difficulty'] = int(kw_difficulty)
subject_cid_list = await Subject.distinct('cid', filtered=query_subject_params)
query_params['$and'] = [
{'subject_cid': {'$in': subject_cid_list}}
]
if category_use:
query_subject_params['category'] = int(category_use)
subject_cid_list = await Subject.distinct('cid', filtered=query_subject_params)
query_params['$and'] = [
{'subject_cid': {'$in': subject_cid_list}}
]
# 分页 START
per_page_quantity = int(self.get_argument('per_page_quantity', 10))
to_page_num = int(self.get_argument('page', 1))
page_url = '%s?page=$page&per_page_quantity=%s&race_cid=%s&kw_name=%s&kw_difficulty=%s&category_use=%s' % (
self.reverse_url("backoffice_race_subject_list"), per_page_quantity, race_cid, kw_name,
kw_difficulty, category_use)
paging = Paging(page_url, RaceSubjectRefer, current_page=to_page_num, pipeline_stages=[h_lookup_stage],
items_per_page=per_page_quantity, **query_params)
await paging.pager()
# 分页 END
return locals()
async def post(self):
res_dict = {'code': 0}
try:
open_id = self.get_i_argument('open_id', '')
if not open_id:
res_dict['code'] = 1001
return res_dict
member = await find_member_by_open_id(open_id)
if not member:
res_dict['code'] = 1002
return res_dict
race_cid = self.get_i_argument('race_cid', '')
if not race_cid:
res_dict['code'] = 1003
return res_dict
stat_list = await RaceCheckPointStatistics.aggregate(stage_list=[
MatchStage({'race_cid': race_cid}),
SortStage([('pass_checkpoint_num', DESC), ('correct_num',
DESC)]),
LimitStage(30),
LookupStage(Member, 'member_cid', 'cid', 'member_list'),
ProjectStage(
**{
'nick_name': {
'$arrayElemAt': ['$member_list.nick_name', 0]
},
'avatar': {
'$arrayElemAt': ['$member_list.avatar', 0]
},
'correct_num': '$correct_num',
'pass_checkpoint_num': '$pass_checkpoint_num'
})
]).to_list(30)
res_dict = {'code': 1000, 'rankings': stat_list}
except Exception:
logger.error(traceback.format_exc())
return res_dict
def get_city_and_district(race_cid):
"""
得到安徽下面的所有市和区
:param race_cid:
:return:
"""
lookup_stage = LookupStage(Member, 'member_cid', 'cid', 'member_list')
race = Race.sync_get_by_cid(race_cid)
city_list = AdministrativeDivision.sync_distinct(
'code', {'parent_code': race.province_code})
city_name_list = AdministrativeDivision.sync_distinct(
'title', {'parent_code': race.province_code})
dist_list = []
for city in city_list:
dist_list += AdministrativeDivision.sync_distinct(
'title', {'parent_code': city})
return city_name_list, dist_list, lookup_stage
async def get(self):
query_params = {'record_flag': 1}
dan_grade_name = self.get_argument('dan_grade_name', '')
if dan_grade_name:
query_params['$or'] = [{
"title": {
'$regex': dan_grade_name,
'$options': 'i'
}
}]
# 分页 START
per_page_quantity = int(self.get_argument('per_page_quantity', 10))
to_page_num = int(self.get_argument('page', 1))
page_url = '%s?page=$page&per_page_quantity=%s&dan_grade_name=%s' % (
self.reverse_url("backoffice_dan_grade_list"), per_page_quantity,
dan_grade_name)
paging = Paging(page_url,
GameDanGrade,
pipeline_stages=[
LookupStage(UploadFiles, 'thumbnail', 'cid',
'image_list')
],
current_page=to_page_num,
items_per_page=per_page_quantity,
sort=['index'],
**query_params)
await paging.pager()
# 分页 END
# 段位缩略图的字典 在第几个位置有图片
thumbnail_dict = dict()
for index, thumbnail in enumerate(paging.page_items):
if thumbnail.image_list:
title_img_url = '%s://%s%s%s%s' % (
SERVER_PROTOCOL, SERVER_HOST, STATIC_URL_PREFIX, 'files/',
thumbnail.image_list[0].title)
thumbnail_dict[index] = title_img_url
print(thumbnail_dict)
return locals()
async def get(self):
city_list = None
province_list = await AdministrativeDivision.find(
dict(parent_code=None)).to_list(None)
race_cid = self.get_argument('race_cid', '')
try:
race_list = await Race.aggregate(stage_list=[
MatchStage({'cid': race_cid}),
LookupStage(UploadFiles, 'image_cid', 'cid', 'image_list')
]).to_list(1)
race = race_list[0] if race_list else None
city_list = None
if race.province_code:
city_list = await AdministrativeDivision.find({
'parent_code':
race.province_code
}).to_list(None)
except Exception:
logger.error(traceback.format_exc())
return locals()
def do_init(model, skip_num, limit_num):
"""
:param model:
:param skip_num:
:param limit_num:
:return:
"""
stage_list = [
MatchStage({
'created_dt': {
"$gte":
datetime.now().replace(day=14, hour=18, minute=15, second=00),
"$lte":
datetime.now().replace(day=17, hour=9, minute=22, second=00)
}
}),
ProjectStage(
**{
'daily_code': {
"$dateToString": {
'format': '%Y%m%d000000',
'date': "$created_dt"
}
},
'member_cid': 1,
'correct': {
'$size': {
'$filter': {
'input': '$result.true_answer',
'as': 'item',
'cond': {
'$and': [{
'$eq': ['$$item', True]
}]
}
}
}
},
'total': {
'$size': '$result'
},
'result': 1,
'created_dt': 1
}),
GroupStage({
'daily_code': '$daily_code',
'member_cid': '$member_cid'
},
correct_list={'$push': "$correct"},
result_list={"$push": "$result"},
created_dt={'$first': "$created_dt"},
correct={'$sum': '$correct'},
total={'$sum': '$total'},
learn_times={'$sum': 1}),
LookupStage(Member, '_id.member_cid', 'cid', 'member_list'),
MatchStage({'member_list': {
'$ne': []
}}),
ProjectStage(
**{
'daily_code': "$_id.daily_code",
'member_cid': '$_id.member_cid',
'correct': '$correct',
'total': "$total",
'correct_list': "$correct_list",
'learn_times': '$learn_times',
'province_code': {
"$arrayElemAt": ['$member_list.province_code', 0]
},
'city_code': {
"$arrayElemAt": ['$member_list.city_code', 0]
},
'district_code': {
"$arrayElemAt": ['$member_list.district_code', 0]
},
'gender': {
"$arrayElemAt": ['$member_list.sex', 0]
},
'age_group': {
"$arrayElemAt": ['$member_list.age_group', 0]
},
'education': {
"$arrayElemAt": ['$member_list.education', 0]
},
'result_list': 1,
'created_dt': 1
}),
SortStage([('daily_code', ASC), ('member_cid', ASC)]),
]
if skip_num:
stage_list.append(SkipStage(skip_num))
if limit_num:
stage_list.append(LimitStage(limit_num))
cursor = MemberGameHistory.sync_aggregate(
stage_list, allowDiskUse=True, read_preference=ReadPreference.PRIMARY)
index = 0
while True:
try:
index += 1
print('has exec %s.' % index)
data = cursor.next()
param = {
'daily_code':
data.daily_code,
'member_cid':
data.member_cid,
'province_code':
data.province_code,
'city_code':
data.city_code,
'district_code':
data.district_code,
'gender':
data.gender,
'age_group':
data.age_group,
'education':
data.education,
'learn_times':
data.learn_times,
'subject_total_quantity':
data.total,
'subject_correct_quantity':
data.correct,
'quantity_detail':
dict(Counter(map(lambda x: str(x), data.correct_list))),
'dimension_detail':
get_dimension_detail(data.result_list),
'created_dt':
data.created_dt,
'updated_dt':
data.created_dt
}
model(**param).sync_save()
except StopIteration:
break
except AttributeError as e:
print(e)
continue
async def _get_survey_url(open_id, survey_action_cid):
if open_id and survey_action_cid:
current_datetime = datetime.datetime.now()
match = MatchStage({
'$and': [{
'cid': survey_action_cid
}, {
'push_datetime': {
'$lte': current_datetime
}
}, {
'pull_types': {
'$in': [PUSH_RECEIVE_WECHAT]
}
}, {
'$or': [{
'start_datetime': None
}, {
'start_datetime': {
'$lte': current_datetime
}
}]
}, {
'$or': [{
'end_datetime': None
}, {
'end_datetime': {
'$gte': current_datetime
}
}]
}]
})
lookup = LookupStage(Questionnaire, 'q_cid', 'cid', 'q_docs')
sort = SortStage([('push_datetime', DESC)])
limit = LimitStage(1)
survey_action_list = await SurveyPushAction.aggregate(
[match, lookup, sort, limit]).to_list(1)
if survey_action_list:
survey_action = survey_action_list[0]
if survey_action:
q_doc_list = survey_action.q_docs
if q_doc_list:
questionnaire = q_doc_list[0]
if questionnaire:
member = await Member.find_one(
dict(open_id=open_id, status=STATUS_USER_ACTIVE))
if member:
history_status_list = [
STATUS_MEMBER_SURVEY_NORMAL,
STATUS_MEMBER_SURVEY_FILTERED,
STATUS_MEMBER_SURVEY_QUOTA_FULLED
]
history_count = await MemberSurveyHistory.count({
'member_cid':
member.cid,
'action_cid':
survey_action_cid,
'status': {
'$in': history_status_list
}
})
if history_count > 0:
return '/wechat/operation/message/?message=%s' % '抱歉，您已经参与过本次调查，您可以点击服务号"我是车主>>最新问卷"参与其他活动。'
else:
survey_history = await MemberSurveyHistory.get_or_create(
dict(member_cid=member.cid,
action_cid=survey_action.cid))
survey_history.start_datetime = datetime.datetime.now(
)
survey_history.status = STATUS_MEMBER_SURVEY_STARTED
survey_history.needless = {
'sa_title':
survey_action.title,
'sa_cover':
survey_action.needless.get('cover_title')
if survey_action.needless else None,
'q_cid':
questionnaire.get('cid'),
'q_title':
questionnaire.get('title')
}
await survey_history.save()
return questionnaire.get(
'url') + '?code=%s&sid=%s' % (
member.code, survey_action_cid)
return '/wechat/operation/message/?message=%s' % '错误！'
return '/wechat/operation/message/?message=%s' % '亲，活动已结束啦，欢迎下次再来！'
async def post(self):
r_dict = {'code': 0}
try:
open_id = self.get_i_argument('open_id', None)
opponent_open_id = self.get_i_argument('opponent_open_id', None)
member = await find_member_by_open_id(open_id)
opponent = await find_member_by_open_id(opponent_open_id)
if not open_id or not opponent_open_id or not member or not opponent:
r_dict['code'] = 1001
return r_dict
game_history = await MemberGameHistory.aggregate([
MatchStage({
'member_cid': opponent.cid,
'runaway_index': None
}),
SortStage([('dan_grade', DESC), ('created_dt', DESC)]),
LimitStage(1)
]).to_list(1)
if not game_history:
# 还未进行过排位赛
r_dict['code'] = 1005
return r_dict
game_history = game_history[0]
history_subject_cid_dict = {
result.get('subject_cid'): result
for result in game_history.result
}
result_map = {
result.get('subject_cid'): {
'remain_time': 20 - result.get('consume_time', 0),
'question_id': result.get('subject_cid'),
'option_id': result.get('selected_option_cid'),
'true_answer': result.get('true_answer'),
'score': result.get('score', 0)
}
for result in game_history.result
}
subject_list = await Subject.aggregate(stage_list=[
MatchStage(
{'cid': {
'$in': list(history_subject_cid_dict.keys())
}}),
LookupStage(SubjectOption,
let={'cid': '$cid'},
pipeline=[{
'$match': {
'$expr': {
'$and': [{
'$eq': ['$subject_cid', '$$cid']
}]
}
}
}, {
'$sort': {
'code': ASC
}
}],
as_list_name='option_list'),
LookupStage(UploadFiles, 'image_cid', 'cid', 'file_list')
]).to_list(None)
answers = []
question_list = []
for subject in subject_list:
title_picture_url = ''
if subject.file_list:
title_picture_url = '%s://%s%s%s%s' % (
SERVER_PROTOCOL, SERVER_HOST, STATIC_URL_PREFIX,
'files/', subject.file_list[0].title)
dimension_dict = await convert_subject_dimension_dict(
subject.dimension_dict)
question = {
'id':
subject.cid,
'title':
subject.title,
'picture_url':
title_picture_url,
'category_name':
dimension_dict.get('学科部类').title,
'timeout':
20,
'difficulty_degree':
'%s/5' % dimension_dict.get('题目难度').ordered,
'knowledge_first':
KNOWLEDGE_FIRST_LEVEL_DICT.get(subject.knowledge_first),
'knowledge_second':
KNOWLEDGE_SECOND_LEVEL_DICT.get(subject.knowledge_second),
'resolving':
subject.resolving,
'option_list': [{
'id': opt.cid,
'title': opt.title,
'true_answer': opt.correct
} for opt in subject.option_list]
}
question_list.append(question)
answers.append(result_map.get(subject.cid))
r_dict = {
'code': 1000,
'question_list': question_list,
'answers': answers
}
except Exception:
logger.error(traceback.format_exc())
return r_dict
