async def post(self):
r_dict = {'code': 0}
open_id = self.get_i_argument('open_id', '')
race_cid = self.get_i_argument('race_cid', '')
if not race_cid:
r_dict['code'] = 1001
return r_dict
try:
member = await find_member_by_open_id(open_id)
if not member.auth_address:
r_dict['code'] = 1002
return r_dict
race = await Race.find_one({'cid': race_cid})
rankings = []
province = member.auth_address.get('province')
city = member.auth_address.get('city')
if not race.city_code:
# 省级活动, 城市排序
match_stage = MatchStage({
'auth_address.province': province,
'race_cid': race_cid
})
group_stage = GroupStage('auth_address.city', sum={'$sum': 1})
else:
# 市级活动, 区域排序
c = await AdministrativeDivision.find_one({
'title': city,
'parent_code': {
"$ne": None
}
})
match_stage = MatchStage({
'auth_address.city': city,
'race_cid': race_cid
})
group_stage = GroupStage('auth_address.district',
sum={'$sum': 1})
area_list = await RaceMapping.aggregate(stage_list=[
match_stage, group_stage,
SortStage([('sum', DESC)])
]).to_list(None)
for area in area_list:
rank = {
'title': area.id if area.id else '其他地区',
'people_count': area.sum
}
rankings.append(rank)
r_dict = {'code': 1000, 'rankings': rankings}
except Exception:
logger.error(traceback.format_exc())
return r_dict
async def do_stat_member_times(race_cid: str,
time_match: MatchStage,
group_id='district',
name_match=MatchStage({}),
district_title="",
name="",
time_num="",
is_integrate=""):
"""
统计参赛人次
:param race_cid:
:param time_match:
:param group_id:
:param name_match
:param district_title
:param name
:param time_num
:param is_integrate
:return:
"""
if not race_cid:
return
cache_key = get_cache_key(
race_cid,
'member_times_{district}_{name}_{time_num}_{district_title}_{is_integrate}'
.format(district=group_id,
name=name,
time_num=time_num,
district_title=district_title,
is_integrate=is_integrate))
member_times_data = RedisCache.get(cache_key)
data_cache = ''
if member_times_data:
data_cache = msgpack.unpackb(member_times_data, raw=False)
if not member_times_data or not data_cache:
# race = await Race.get_by_cid(race_cid)
all_match = {'race_cid': race_cid}
# 安徽特殊处理，需整合六安数据(弃用)
if is_integrate:
all_match = {'race_cid': {'$in': [race_cid, CITY_RACE_CID]}}
district_match = MatchStage({})
if district_title:
district_match = MatchStage({'district': district_title})
all_match['town'] = {'$ne': None}
cursor = RaceMemberEnterInfoStatistic.aggregate([
MatchStage(all_match), district_match, time_match, name_match,
GroupStage(group_id, sum={'$sum': '$enter_times'}),
SortStage([('sum', DESC)])
])
times_data = await stat_data(cursor)
logger_cache.info('cache_key: %s' % cache_key)
RedisCache.set(cache_key, msgpack.packb(times_data), 23 * 60 * 60)
return times_data
return msgpack.unpackb(member_times_data, raw=False)
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 post(self):
res_dict = {'code': 0}
choice_time = int(self.get_argument("choice_time", 0))
group_id = self.get_argument("category", "city")
race_cid = self.get_argument("race_cid")
early_monring = datetime.now().replace(hour=0,
minute=0,
second=0,
microsecond=0)
end_daily_code = format(early_monring, '%Y%m%d')
time_match = MatchStage({'daily_code': {'$lt': end_daily_code}})
if choice_time:
old_time = early_monring - timedelta(choice_time)
start_daily_code = format(old_time, '%Y%m%d')
time_match = MatchStage({
'daily_code': {
'$gt': start_daily_code,
'$lt': end_daily_code
}
})
data = []
try:
member_times = await do_stat_member_times(race_cid,
time_match,
group_id,
time_num=choice_time)
member_count = await do_stat_member_count(race_cid,
time_match,
group_id,
time_num=choice_time)
member_accuracy = await do_stat_member_accuracy(
race_cid, time_match, group_id, time_num=choice_time)
for k in member_times:
data.append({
'name':
k,
'times':
member_times.get(k, 0),
'count':
member_count.get(k, 0),
'accuracy':
"%.2f%%" % (member_accuracy.get(k, 0.0) * 100)
})
except Exception:
res_dict['code'] = -1
logger.error(traceback.format_exc())
return res_dict
html = self.render_string('frontsite/report/rank_table.html',
data=data)
if html:
html = html.decode('utf-8')
return {'code': 1, 'html': html}
async def post(self):
r_dict = {'code': 0}
race_cid = self.get_argument('race_cid', '')
condition = self.get_argument('condition_value')
group_type = self.get_argument('group_type', 'date')
count_pass = self.get_argument('count_pass')
if count_pass:
sum_value = '$pass_num'
else:
sum_value = '$people_num'
pre_data = self.get_argument('pre_data')
query = {'race_cid': race_cid, 'record_flag': 1}
if pre_data:
pre_data: dict = json.loads(pre_data)
query.update(pre_data)
match_stage = MatchStage(query)
stage_list = [match_stage, MatchStage(parse_race_condition(condition))]
sort_stage = SortStage([('sum', DESC)])
group_id = None
if group_type == 'date':
group_id = 'daily_code'
sort_stage = SortStage([('_id', ASC)])
if group_type == 'province':
group_id = 'province'
if group_type == 'city':
group_id = 'city'
if group_type == 'district':
group_id = 'district'
group_stage = GroupStage(group_id, sum={'$sum': sum_value})
stage_list += [group_stage, sort_stage]
try:
stats = await ReportRacePeopleStatistics.aggregate(stage_list
).to_list(None)
series_data = [s.sum for s in stats]
x_axis_data = [s.id for s in stats if s]
if not x_axis_data:
x_axis_data = ['暂无数据']
r_dict = {
'code': 1,
'bar': {
'xAxisData': x_axis_data,
'seriesData': series_data
}
}
except Exception:
logger.error(traceback.format_exc())
return r_dict
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
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_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_items(self):
index_s = (self.__current_page - 1) * self.__items_per_page
if self.__use_pipeline:
pipelines = []
if self.__query_params:
pipelines.append(MatchStage(self.__query_params))
if self.__stages:
pipelines.extend(self.__stages)
if self.__sort:
sort_stage = SortStage(self.__sort)
pipelines.append(sort_stage)
skip_stage = SkipStage(index_s if index_s >= 0 else 0)
pipelines.append(skip_stage)
limit_stage = LimitStage(self.__items_per_page)
pipelines.append(limit_stage)
if self.__left_stages:
pipelines.extend(self.__left_stages)
return await self.__document.aggregate(pipelines).to_list(self.__items_per_page)
else:
return await self.__document.find(self.__query_params).skip(index_s).limit(self.__items_per_page).sort(
self.__sort).to_list(self.__items_per_page)
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 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
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(self):
race_cid = self.get_argument('race_cid', '')
menu_list = await get_menu(self, 'config', race_cid)
rule_cid = self.get_argument('rule_cid', '')
# 已经设置好的红包基础设置
basic_setting_match = MatchStage({
'record_flag': 1,
'race_cid': race_cid,
'rule_cid': rule_cid
})
basic_setting_sort = SortStage([('updated_dt', DESC)])
basic_set_list = await RedPacketBasicSetting.aggregate(
stage_list=[basic_setting_match, basic_setting_sort]).to_list(None)
if basic_set_list:
basic_set = basic_set_list[0]
if not basic_set_list:
basic_set = RedPacketBasicSetting()
# 已经设置好的奖项设置
red_packet_item_list = await RedPacketItemSetting.find({
'record_flag':
1,
'race_cid':
race_cid,
'rule_cid':
rule_cid
}).sort('-amount').to_list(None)
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 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 _async_query(self,
dimension_cid_pair_list: list = None,
length=4):
"""
异步查询
:param dimension_cid_pair_list:
:param length:
:return:
"""
query_params = {
'status': STATUS_SUBJECT_ACTIVE,
'race_cid': self.race_cid,
}
if self.__option_condition_list:
for option_condition in self.__option_condition_list:
query_params['dimension_dict.%s' % option_condition[0]] = {
'$in': option_condition[1]
}
if dimension_cid_pair_list:
for dimension_cid_pair in dimension_cid_pair_list:
query_params['dimension_dict.%s' %
dimension_cid_pair[0]] = dimension_cid_pair[1]
match_stage = MatchStage(query_params)
sample_stage = SampleStage(length)
return await RaceSubjectRefer.aggregate([match_stage,
sample_stage]).to_list(None)
async def _async_query(self,
dimension_cid_pair_list: list = None,
length=4):
"""
异步查询
:param dimension_cid_pair_list:
:param length:
:return:
"""
query_params = {
'status': STATUS_SUBJECT_ACTIVE,
'category_use': {
'$nin':
[CATEGORY_SUBJECT_BENCHMARK, CATEGORY_SUBJECT_GRADUATION]
}
}
if self.__option_condition_list:
for option_condition in self.__option_condition_list:
query_params['dimension_dict.%s' % option_condition[0]] = {
'$in': option_condition[1]
}
if dimension_cid_pair_list:
for dimension_cid_pair in dimension_cid_pair_list:
query_params['dimension_dict.%s' %
dimension_cid_pair[0]] = dimension_cid_pair[1]
match_stage = MatchStage(query_params)
sample_stage = SampleStage(length)
return await Subject.aggregate([match_stage,
sample_stage]).to_list(None)
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)
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()
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()
def change_duplicate_race_mapping(race_cid: str):
print("race_cid:%s" % race_cid)
match_stage = MatchStage({'race_cid': race_cid, 'record_flag': 1})
project_stage = ProjectStage(**{
"race_cid": 1,
"member_cid": 1,
"race_check_point_cid": 1
})
group_stage = GroupStage({'_id': '$member_cid'},
count={'$sum': 1},
duplicate_list={'$push': '$$ROOT'})
match_stage_count = MatchStage({'count': {'$gt': 1}})
project_stage_1 = ProjectStage(**{'duplicate_list': 1})
duplicate_race_mappings = RaceMapping.sync_aggregate([
match_stage, project_stage, group_stage, match_stage_count,
project_stage_1
]).to_list(None)
count = 1
if len(duplicate_race_mappings) > 0:
for duplicate_race_mapping in duplicate_race_mappings:
print('第%d个:' % count)
print(duplicate_race_mapping.duplicate_list)
duplicate_record_ids = [
x._id for x in duplicate_race_mapping.duplicate_list
]
not_need_index = 0 # 确定record_flag为1的元素
for index, value in enumerate(
duplicate_race_mapping.duplicate_list):
if value.race_check_point_cid:
not_need_index = index
duplicate_record_ids.pop(not_need_index)
print("record_flag需置为0的记录Id:")
print(duplicate_record_ids)
update_requests = []
for object_id in duplicate_record_ids:
update_requests.append(
UpdateOne({'_id': object_id}, {'$set': {
'record_flag': 0
}}))
RaceMapping.sync_update_many(update_requests)
print("-------END:record_flag已置为0---------------")
count += 1
else:
print("-------未找到member_cid重复的记录-------")
print("-------结束处理活动-------")
def get_member_info(thread_num, race_member_list, checkPointCidList, lastCheckPoint, checkPointMap):
exportedMemberList = []
for race_member in race_member_list:
# raceMapping = race_member.race_list[0]
raceMapping = race_member
race_cid = raceMapping.race_cid
member = race_member.member_list[0]
memberCid = member.cid
red_match = MatchStage(
{'race_cid': race_cid, 'member_cid': memberCid, 'draw_status': 0, 'draw_dt': {'$ne': None},
'award_cid': {'$ne': None}, 'record_flag': 1})
red_project = ProjectStage(**{"member_cid": 1, "award_amount": 1})
red_group = GroupStage('member_cid', count={'$sum': 1}, amount={'$sum': '$award_amount'})
# redPacketsOfMember = RedPacketBox.sync_find(
# {'race_cid': race_cid, 'member_cid': memberCid, 'award_cid': {'$ne': None}, 'record_flag': 1})
# eachAmountOfRedPacket = [redPacket.award_amount for redPacket in redPacketsOfMember]
redPacketsOfMemberCursor = RedPacketBox.sync_aggregate([red_match, red_project, red_group]).batch_size(50)
exportedMember = MemberInfoExportedModel()
exportedMember.open_id = member.open_id
exportedMember.member_cid = memberCid
exportedMember.nick = member.nick_name
exportedMember.firstTimeOfEnroll = member.created_dt
city = raceMapping.auth_address.get('city', '')
exportedMember.city = city if not city is None else ''
district = raceMapping.auth_address.get('district', '')
exportedMember.district = district if not district is None else ''
mobile = getattr(raceMapping, 'mobile', '')
if mobile is None:
exportedMember.mobile = member.mobile
else:
exportedMember.mobile = mobile
check_point_cid = getattr(raceMapping, 'race_check_point_cid', None)
if check_point_cid is None:
exportedMember.currentCheckPoint = "1"
elif check_point_cid == lastCheckPoint:
exportedMember.currentCheckPoint = "已通关"
else:
exportedMember.currentCheckPoint = str(checkPointMap[check_point_cid])
answerTimes = MemberCheckPointHistory.sync_find(
{'member_cid': memberCid, 'check_point_cid': {'$in': checkPointCidList}, 'record_flag': 1}).to_list(None)
exportedMember.answerTimes = len(answerTimes)
try:
redPacketsOfMember = redPacketsOfMemberCursor.next()
if redPacketsOfMember:
exportedMember.totalNumOfRedPacket = redPacketsOfMember.count
exportedMember.totalAmountOfRedPacket = round(redPacketsOfMember.amount, 2)
except StopIteration:
pass
exportedMemberList.append(exportedMember)
print(thread_num, member.cid, exportedMember.nick, exportedMember.city, exportedMember.district,
exportedMember.mobile,
exportedMember.currentCheckPoint, exportedMember.answerTimes, exportedMember.totalNumOfRedPacket,
exportedMember.totalAmountOfRedPacket)
return exportedMemberList
async def post(self):
r_dict = {'code': 0}
try:
pageNum = int(self.get_i_argument('pageNum', 1))
size = int(self.get_i_argument('size', 10))
skip = (pageNum - 1) * size if (pageNum - 1) * size > 0 else 0
filter_dict = {'db_mark': {'$ne': ''}, 'release_time': {'$ne': ''}}
match = MatchStage(filter_dict)
skip = SkipStage(skip)
sort = SortStage([('release_time', DESC)])
limit = LimitStage(int(size))
count = await Tvs.count({
'db_mark': {
'$ne': ''
},
'release_time': {
'$ne': ''
}
})
tvs = await Tvs.aggregate([match, sort, skip, limit]).to_list(None)
new_tvs = []
for tv in tvs:
new_tvs.append({
'id':
str(tv.id),
'name':
tv.name,
'pic_url':
tv.pic_url,
'db_mark':
tv.db_mark,
'actor':
tv.actor,
'source_nums':
len(tv.download),
'release_time':
tv.release_time.strftime('%Y-%m-%d'),
'label':
api_utils.get_show_source_label(tv),
'recommend_info':
'这部神剧值得一看。',
'set_num':
tv.set_num if tv.set_num else '',
's_type':
'tv'
})
r_dict['tvs'] = new_tvs
r_dict['count'] = count
r_dict['code'] = 1000
except Exception:
logger.error(traceback.format_exc())
print('latest')
print(r_dict)
return r_dict
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()
def export_new_info(workbook, race_cid, s_daily_code='', e_daily_code=''):
"""
新增信息
:param workbook:
:param race_cid:
:param s_daily_code:
:param e_daily_code:
:return:
"""
match = MatchStage({'race_cid': race_cid})
if s_daily_code and e_daily_code:
match['daily_code'] = {'$gte': s_daily_code, '$lte': e_daily_code}
group = GroupStage(
{
'daily_code': '$daily_code',
'race_cid': '$race_cid'
},
enter_times={'$sum': '$enter_times'},
draw_red_packet_count={'$sum': '$draw_red_packet_count'},
draw_red_packet_amount={'$sum': '$draw_red_packet_amount'},
new_user_count={'$sum': '$is_new_user'})
sort = SortStage([('_id.daily_code', ASC)])
total_user_count = 0
total_enter_times = 0
total_draw_red_packet_count = 0
total_draw_red_packet_amount = 0
exported_member_list = MemberStatisticInfo.sync_aggregate(
[match, group, sort]).to_list(None)
sheet = workbook.add_worksheet("新增信息")
sheet.merge_range(0, 0, 0, 1, '日期')
sheet.merge_range(0, 2, 0, 3, '新增会员数')
sheet.merge_range(0, 4, 0, 5, '新增答题次数')
sheet.merge_range(0, 6, 0, 7, '新增红包领取数')
sheet.merge_range(0, 8, 0, 9, '新增红包领取金额')
sheet.merge_range(0, 10, 0, 11, '总会员数')
sheet.merge_range(0, 12, 0, 13, '总答题次数')
sheet.merge_range(0, 14, 0, 15, '总红包领取数')
sheet.merge_range(0, 16, 0, 17, '总红包领取金额')
for index, info in enumerate(exported_member_list):
row = index + 1
sheet.merge_range(row, 0, row, 1, info.id.get('daily_code'))
sheet.merge_range(row, 2, row, 3, info.new_user_count)
sheet.merge_range(row, 4, row, 5, info.enter_times)
sheet.merge_range(row, 6, row, 7, info.draw_red_packet_count)
sheet.merge_range(row, 8, row, 9, info.draw_red_packet_amount)
total_user_count += info.new_user_count
total_enter_times += info.enter_times
total_draw_red_packet_count += info.draw_red_packet_count
total_draw_red_packet_amount += info.draw_red_packet_amount
sheet.merge_range(row, 10, row, 11, total_user_count)
sheet.merge_range(row, 12, row, 13, total_enter_times)
sheet.merge_range(row, 14, row, 15, total_draw_red_packet_count)
sheet.merge_range(row, 16, row, 17, total_draw_red_packet_amount)
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_red_packet_info(race_cid, start_date, end_date):
"""
统计当日该会员参加活动时，红包领取数量、领取金额、发放数量
:param race_cid:
:param start_date:
:param end_date:
:return:
"""
cursor = RedPacketBox.sync_aggregate([
MatchStage({
'draw_dt': {
"$gte": start_date,
"$lt": end_date
},
'race_cid': race_cid,
'award_cid': {
'$ne': None
}
}),
GroupStage({
'member_cid': '$member_cid',
'draw_status': '$draw_status'
},
amount={'$sum': '$award_amount'},
sum={"$sum": 1})
])
ret = {}
while True:
try:
data = cursor.next()
_member = data.id.get('member_cid')
_status = data.id.get('draw_status')
_value = ret.get(_member)
if not _value:
_value = {
'grant_count': 0,
'grant_amount': 0,
'draw_count': 0,
'draw_amount': 0
}
_value['grant_count'] += data.sum
_value['grant_amount'] += data.amount
if _status == 0:
_value['draw_count'] += data.sum
_value['draw_amount'] += data.amount
ret[_member] = _value
except StopIteration:
break
return ret
def test2(race_cid):
total = MemberStatisticInfo.sync_count({
'race_cid': race_cid,
'is_new_user': 1
})
cursor = MemberStatisticInfo.sync_aggregate([
MatchStage({
'race_cid': race_cid,
'is_new_user': 1
}),
GroupStage('member_cid', count={'$sum': 1}),
MatchStage({'count': {
'$gt': 1
}})
])
for stat in cursor:
print(stat.id, stat.count)
cursor1 = MemberStatisticInfo.sync_find({'member_cid': stat.id})
for s in cursor1:
print(s.daily_code, s.is_new_user, s.is_special_user)
print(total)