async def user_owner_group_info(user_id, page_size, current_page):
"""查询用户群主群信息"""
async with db.conn.acquire() as con:
if page_size == -1:
st = await con.prepare('''
select "group".id::varchar , "group".code, "group".name, launch_switch,mem_count, welcome_msg,
to_char("group".create_date, 'YYYY-MM-DD HH24:MI:SS') as create_date from "group" left join "user" on
"group".user_id = "user".id where user_id = $1 and "group".owner_user_code = "user".code
and "group".status !=3 order by create_date desc''')
groups = records_to_list(await st.fetch(user_id))
else:
st = await con.prepare('''
select "group".id::varchar , "group".code, "group".name,mem_count, welcome_msg, launch_switch,
to_char("group".create_date, 'YYYY-MM-DD HH24:MI:SS') as create_date from "group" left join "user" on
"group".user_id = "user".id where user_id = $1 and owner_user_code = "user".code and "group".status !=3
order by create_date desc limit $2 offset $3''')
groups = records_to_list(await st.fetch(
user_id, int(page_size),
int(current_page) * int(page_size)))
select_count = await con.prepare(
'''select count(1) from "group" left join "user" on "group".user_id="user".id
where user_id = $1 and owner_user_code ="user".code and "group".status !=3'''
)
total_records = await select_count.fetchval(user_id)
page_info = get_page_info(page_size, current_page, total_records)
return groups, page_info
async def get_group_list(request, user, **kwargs):
"""获取用户的群列表"""
user_id = user.get('user_id')
status = request.raw_args.get('status')
current_page = int(request.raw_args.get('current_page', 0))
page_size = int(request.raw_args.get('page_size', 20))
user_groups = []
total_records = 0
async with db.conn.acquire() as con:
if int(status) == group_status['normal']:
select_stmt = await con.prepare('''
select "group".code, "group".launch_switch, "group".settle_count, "group".quality_level, "group".old_group,
robot_group_map.nickname,"group".name , "robot".name as robot_name from "group" left join robot_group_map on
"group".id = "robot_group_map".group_id left join robot on robot.id = "robot_group_map".robot_id where
"group".user_id = $1 and "group".status<>3 and "robot_group_map".status <>3 and "robot".status<>3 and
(quality_level is not null or old_group = 1) order by "group".create_date desc limit $2 offset $3'''
)
user_groups = records_to_list(await select_stmt.fetch(
user_id, int(page_size),
int(current_page) * int(page_size)))
select_count = await con.prepare(
'''select count(1) from "group" left join robot_group_map on
"group".id = robot_group_map.group_id left join robot on robot.id = robot_group_map.robot_id
where "group".user_id = $1 and "group".status<>3 and "robot_group_map".status <>3 and "robot".status<>3
and (quality_level is not null or old_group = 1)''')
total_records = await select_count.fetchval(user_id)
elif int(status) == group_status['error']:
select_stmt = await con.prepare('''
select "group".code , "group".name, to_char("group".create_date, 'YYYY-MM-DD') as create_date from "group" where "group".user_id = $1 and "group".status != 3 and old_group != 1
and quality_level is null order by "group".create_date desc limit $2 offset $3'''
)
user_groups = records_to_list(await select_stmt.fetch(
user_id, int(page_size),
int(current_page) * int(page_size)))
select_count = await con.prepare('''select count(1) from "group"
where user_id = $1 and status != 3 and quality_level is null and old_group != 1'''
)
total_records = await select_count.fetchval(user_id)
page_info = get_page_info(page_size, current_page, total_records)
if len(user_groups) > 0 and int(status) == group_status['normal']:
for item in user_groups:
if not item['old_group']:
if item['settle_count'] >= 30 and item['launch_switch'] == 0:
income_status = '未收益'
else:
income_status = '收益中'
item['income_status'] = income_status
item['group_income'] = group_income[item['quality_level']]
item['text_income'] = click_income
item['robot_name'] = item['nickname'] if item[
'nickname'] else item['robot_name']
item.pop('nickname')
return response_json(user_groups, page_info=page_info)
async def robot_blocked(data):
"""
机器人封号
1. 缓存机器人封号时的状态
2. 将该机器人置为封号状态
"""
logger.info(f'robot blocked with params:{data}')
robot_code = data.get('robot_id')
async with db.conn.acquire() as con:
get_robot_user_group_stmt = await con.prepare('''
select "group".user_id, "group".id as group_id from "robot"
join "robot_group_map" on "robot".id = "robot_group_map".robot_id
join "group" on robot_group_map.group_id ="group".id where "robot".code = $1 and "robot".status <> 3 and "robot_group_map".status <> 3 order by "group".user_id'''
)
robot_user_group_records = await get_robot_user_group_stmt.fetch(
robot_code)
robot_user_groups = records_to_list(robot_user_group_records)
get_robot_stmt = await con.prepare(
'''select id::varchar from "robot" where code = $1''')
robot_id = await get_robot_stmt.fetchval(robot_code)
redis_key = ROBOT_BLOCKED_REDIS_KEY.format(robot_code=robot_code)
for user_id, items in groupby(robot_user_groups,
key=itemgetter('user_id')):
group_ids = [item('group_id') for item in items]
await redis.conn.hset(redis_key, user_id, dumps(group_ids))
await redis.conn.expire(redis_key, 60 * 60 * 24 * 7)
for group_id in group_ids:
await currency_delete_group(group_id,
GroupCancelReason.ROBOT_BLOCKED)
await remove_robot_distribute(robot_id)
update_robot_stmt = await con.prepare(
'''update "robot" set status = 5, update_date = now() where code = $1 and status <> 3'''
)
await update_robot_stmt.fetch(robot_code)
async def mass_message_data(direction, current_page, page_size):
async with db.conn.acquire() as con:
if direction == 'up':
st = await con.prepare(
'''select to_char(send_date, 'YYYY-MM-DD HH24:MI:SS') as send_date,
jsonb_array_length(group_ids)::int as group_counts, status, id
from "group_task" where user_id=$1 and status <> $2 and type=1
and send_date >= timestamp 'today' and send_date <= (current_date + interval '3' day)
order by send_date desc limit $3 offset $4''')
st_count = await con.prepare(
'''select count(1) from "group_task" where user_id=$1 and status <> $2 and type=1
and send_date >= timestamp 'today' and send_date < (current_date + interval '3' day)'''
)
else:
st = await con.prepare(
'''select to_char(send_date, 'YYYY-MM-DD HH24:MI:SS') as send_date,
jsonb_array_length(group_ids)::int as group_counts, status, id
from "group_task" where user_id=$1 and status <> $2 and type=1
and send_date < timestamp 'today' and send_date >= (current_date - interval '3' day)
order by send_date desc limit $3 offset $4''')
st_count = await con.prepare(
'''select count(1) from "group_task" where user_id=$1 and status <> $2 and type=1
and send_date < timestamp 'today' and send_date >= (current_date - interval '3' day)'''
)
count = await st_count.fetchval(user['user_id'], FAIL_DELETE)
datas = await st.fetch(user['user_id'], FAIL_DELETE, page_size,
current_page * page_size)
return records_to_list(datas), count
async def get_problem_category(request, *args, **kwargs):
"""获取问题列表"""
async with db.conn.acquire() as con:
select_category = await con.prepare(
'''select id, title, seq_no, type from "user_problem_category"
where status !=3''')
problem_category = records_to_list(await select_category.fetch())
return response_json(problem_category)
async def account_stat(account_id):
async with db.conn.acquire() as con:
balance_detail = await con.prepare(
'''select to_char(settle_date, 'YYYY-MM-DD') as day,
sum(case when balance_type = 1 then change_amount else -change_amount end) as balance_detail
from "account_slip" where account_id=$1 and create_date::date >= (current_date - interval '14' day)
and amount_type <> 9 group by day order by day desc''')
balance = await balance_detail.fetch(account_id)
return records_to_list(balance)
async def chat_statistics():
async with db.conn.acquire() as con:
chat_stmt = await con.prepare(
'''select g.user_id, tmp.group_code as code, tmp.mem_count as counts
from (select m.group_code, count(distinct mem_code) as mem_count from "message" m
where m.send_date >= timestamp 'yesterday' and m.send_date < timestamp 'today'
group by m.group_code) tmp join "group" g on g.code=tmp.group_code
where g.status<>3 order by g.user_id''')
chats = await chat_stmt.fetch()
return records_to_list(chats)
async def get_user_distribute_robots(request, *args, **kwargs):
"""获取当前用户已分配的机器人列表"""
user_id = kwargs['user']['user_id']
async with db.conn.acquire() as con:
select_robots = await con.prepare(
'''select "robot".id, "robot".name, "robot".wechat_no from "robot" left join "robot_distribute" on
"robot_distribute".robot_id = "robot".id where "robot_distribute".user_id = $1 and
"robot_distribute".status !=3 and "robot".status !=3''')
robots = records_to_list(await select_robots.fetch(user_id))
return response_json(robots)
async def need_settlement_groups(groups):
groups_join = ','.join(groups.keys())
async with db.conn.acquire() as con:
st = await con.prepare(
'''select "group".id as group_id, "group".code, "user".id as user_id, "user".code as user_code
from "group" join "user" on "group".user_id="user".id where "group".status<>3 and
exists(select tmp_code from (select unnest(string_to_array($1, ',')) as tmp_code) as tmp where tmp.tmp_code="group".code)
order by "user".code''')
data = await st.fetch(groups_join)
return records_to_list(data)
async def statistics_withdraw_user():
'''统计打款用户'''
async with db.conn.acquire() as con:
st = await con.prepare(
'''select distinct "account_withdraw".user_id from "account_withdraw"
join "user" on "user".id="account_withdraw".user_id
where "account_withdraw".status = $1 and "account_withdraw".review_status = $2
and "user".status=1 group by "account_withdraw".user_id''')
wd_users = await st.fetch(WITHDRAWING, REVIEW_SUCCESSED)
logger.info(f'statistics user withdraw count: {len(wd_users)}')
return records_to_list(wd_users)
async def problem_feedback_export(request, *args, **kwargs):
params = request.json
sql, sql_count = await problem_sql(params)
async with db.conn.acquire() as con:
select_result = records_to_list(await con.fetch(sql))
if not select_result:
return response_json(None)
title = [
'phone', 'nickname', 'title', 'code', 'robot_name', 'robot_wechat_no',
'group_name', 'description', 'create_date'
]
out = io.BytesIO()
workbook = xlsxwriter.Workbook(out)
worksheet = workbook.add_worksheet()
for item in title:
worksheet.write(0, title.index(item), item)
for item in select_result:
worksheet.write(
select_result.index(item) + 1, 0,
item['phone'] if item['phone'] is not None else '')
worksheet.write(
select_result.index(item) + 1, 1,
item['nickname'] if item['nickname'] is not None else '')
worksheet.write(
select_result.index(item) + 1, 2,
item['title'] if item['title'] is not None else '')
worksheet.write(
select_result.index(item) + 1, 3,
item['code'] if item['code'] is not None else '')
worksheet.write(
select_result.index(item) + 1, 4,
item['wechat_no'] if item['wechat_no'] is not None else '')
worksheet.write(
select_result.index(item) + 1, 5,
item['name'] if item['name'] is not None else '')
worksheet.write(
select_result.index(item) + 1, 6,
item['group_name'] if item['group_name'] is not None else '')
worksheet.write(
select_result.index(item) + 1, 7,
item['description'] if item['description'] is not None else '')
worksheet.write(
select_result.index(item) + 1, 8,
item['create_date'] if item['create_date'] is not None else '')
workbook.close()
out.seek(0)
filename = quote("问题反馈列表.xlsx")
return raw(out.getvalue(),
headers={
'Content-Disposition':
'attachment;filename*=utf-8{0}'.format(filename)
},
content_type='application/vnd.ms-excel;chartset=utf-8')
async def get_user_ids(datetime, user_ids):
async with db.conn.acquire() as con:
st = await con.prepare(
'''select "user".id as user_id, "user".code as user_code, "group".code as group_code from "user"
join "group" on "user".id="group".user_id
where "user".status<>3 and "group".status <>3 and "user".create_date <= to_timestamp($1, 'YYYY-MM-DD HH24:MI:SS')
and "group".create_date <= to_timestamp($2, 'YYYY-MM-DD HH24:MI:SS') and "user".id=any($3) order by "user".id'''
)
users = await st.fetch(datetime, datetime, user_ids)
return records_to_list(users), records_to_value_list(
users, 'user_code')
async def day_account_detail(account_id):
async with db.conn.acquire() as con:
select_stmt = await con.prepare(
'''select sum(case when balance_type = 1 then change_amount when balance_type = 2 then -change_amount end)::varchar as balance,
case when amount_type = 1 then 0 when amount_type =2 then 1 when amount_type in (3, 4) then 2
when amount_type = 8 then 3 when amount_type in (5, 10) then 4 end as slip_type,
to_char(settle_date, 'YYYY-MM-DD') as day from "account_slip"
where account_id=$1 and create_date >= current_date - interval '14' day
and amount_type not in (6, 7, 9) group by day, slip_type order by day desc, slip_type'''
)
day_balance_detail = await select_stmt.fetch(account_id)
return records_to_list(day_balance_detail)
async def user_apprentice(user_id, current_page, page_size, leave):
"""获取用户徒弟徒孙信息"""
if user_id is None:
return None
async with db.conn.acquire() as con:
share_records = []
count = 0
if leave == APPRENTICE:
select_stmt = await con.prepare(
'''select "sharing_record".user_id::varchar , to_char("sharing_record".create_date, 'YYYY-MM-DD HH24:MI:SS')
as create_date, "user".nickname, "user".need_remind from "sharing_record" left join "user" on
"user".id = "sharing_record".user_id where "sharing_record".status != 3 and
"sharing_record".sharing_user_id = $1 order by "sharing_record".create_date desc limit $2 offset $3'''
)
share_records = records_to_list(await select_stmt.fetch(
user_id, page_size, current_page * page_size))
select_count = await con.prepare(
'''select count(1) from "sharing_record"
where status != 3 and sharing_user_id = $1''')
count = await select_count.fetchval(user_id)
elif leave == GRANDSON:
select_stmt = await con.prepare(
'''with t as (select user_id from "sharing_record" where status != 3 and sharing_user_id = $1 )
select "sharing_record".user_id::varchar , to_char("sharing_record".create_date, 'YYYY-MM-DD HH24:MI:SS')
as create_date, "user".nickname, "user".need_remind from t,"sharing_record" left join "user" on "user".id = "sharing_record".user_id
where "sharing_record".status != 3 and "sharing_record".sharing_user_id = t.user_id
order by "sharing_record".create_date desc limit $2 offset $3'''
)
share_records = records_to_list(await select_stmt.fetch(
user_id, page_size, current_page * page_size))
select_count = await con.prepare(
'''select count(1) from "sharing_record"
where status != 3 and sharing_user_id in (select user_id from "sharing_record" where status != 3 and
sharing_user_id = $1)''')
count = await select_count.fetchval(user_id)
result = {
'infos': await disciple_result_params(share_records),
'page_info': get_page_info(page_size, current_page, count)
}
return result
async def get_msg_context(request, group_code, msg_id, *args, **kwargs):
"""获取消息上下文"""
logger.info(f'msg_context,group_id:{group_code},msg_id:{msg_id}')
group_user_robot_info = await map_group_relationship(code=group_code)
if group_user_robot_info is None:
return response_json(None, code=RESOURCE_NOT_FOUND_CODE, msg='群信息不存在')
async with db.conn.acquire() as con:
msg_st = await con.prepare('''
with cte as (select send_date from message where id =$1) (select message.id,message.content,
to_char(message.send_date, 'YYYY-MM-DD HH24:MI:SS') as send_date, message.mem_code from message,cte where
message.group_code =$2 and cte.send_date >= message.send_date order by message.send_date desc limit 21) union
(select message.id,message.content, to_char(message.send_date, 'YYYY-MM-DD HH24:MI:SS') as send_date,
message.mem_code from message,cte where message.group_code = $3 and cte.send_date < message.send_date order by
message.send_date asc limit 20) order by send_date asc;''')
msg = records_to_list(await msg_st.fetch(msg_id, group_code,
group_code))
user_codes = []
for msg_detail in msg:
if msg_detail['mem_code'] not in user_codes:
user_codes.append(msg_detail['mem_code'])
request_param = '|'.join(user_codes) # 参数格式为 aaa|bbb|ccc
mem_response = await group_mem_info(request_param)
if int(mem_response['code']) == 100 and mem_response['content']:
mem_info_list = mem_response['content']
else:
return response_json(None, MEM_INFO_FAIL_CODE, '获取群成员信息失败')
logger.debug(f'mem_response:[{mem_info_list}]')
mem_info_dict = {}
for mem_info in mem_info_list:
mem_info_dict[mem_info['id']] = {
'mem_code': mem_info['id'],
'head_url': mem_info['avatar'],
'nickname': mem_info['nickname']
}
for msg_detail in msg:
msg_detail.update(mem_info_dict[msg_detail['mem_code']])
if msg_detail['mem_code'] == group_user_robot_info['robot_code'] or \
msg_detail['mem_code'] == group_user_robot_info['user_code']:
msg_detail['is_master'] = True
else:
msg_detail['is_master'] = False
msg_detail['content'] = ujson.loads(msg_detail['content'])
# 修改@消息为已读
async with db.conn.acquire() as con:
update_alt_msg = await con.prepare(
'''update "alt_msg" set status =1 where msg_id =$1''')
await update_alt_msg.fetchrow(msg_id)
return response_json(data=msg)
async def withdraw_list_admin(request, *args, **kwargs):
"""提现列表"""
current_page = int(request.raw_args.get('current_page', 0))
page_size = int(request.raw_args.get('page_size', 20))
params = request.json
sql, sql_count = await withdraw_sql(params)
sql = sql + ''' limit ''' + str(page_size) + ''' offset ''' + str(
current_page * page_size)
async with db.conn.acquire() as con:
select_result = records_to_list(await con.fetch(sql))
select_count = await con.fetchval(sql_count)
page_info = get_page_info(page_size, current_page, select_count)
return response_json(select_result, page_info=page_info)
async def user_remind():
'''用户提醒,定时扫描'''
logger.info(f'user_remind start!')
async with db.conn.acquire() as con:
select_user = await con.prepare('''
select id, code, need_remind, create_date from "user" where need_remind @> '{"remind":1}'::jsonb and
(need_remind @> '{"is_import":0}'::jsonb or (need_remind @> '{"is_import":1}'::jsonb and
need_remind @> '{"is_apprentice":0}'::jsonb)) and extract(epoch FROM (now() - create_date)) > 3600*24 and
extract(epoch FROM (now() - create_date)) < 3600*36''')
users = records_to_list(await select_user.fetch())
if not users:
logger.debug(f'user_remind users not exist!')
return
logger.info(f'need remind users counts: {len(users)}')
import_remind_user = []
apprentice_remind_user = []
for user in users:
async with db.conn.acquire() as con:
select_add_robot = await con.prepare(
'''select "robot".code from "robot_add_friend" left join "robot" on "robot".id = robot_add_friend.robot_id
where "robot_add_friend".user_id = $1 order by robot_add_friend.create_date desc limit 1'''
)
robot_code = await select_add_robot.fetchval(user['id'])
need_remind = ujson.loads(user['need_remind'])
if need_remind['is_import'] == NOT_IMPORT_GROUP:
await send_text_msg(robot_code, user['code'], NOT_IMPORT_GROUP_MSG)
import_remind_user.append(user['id'])
elif need_remind['is_import'] == HAS_IMPORT_GROUP and need_remind[
'is_apprentice'] == NOT_APPRENTICE:
url = POST_URL.format(user_id=user['id'])
await send_image_msg(robot_code, user['code'], url)
await send_text_msg(robot_code, user['code'],
IMPORT_GROUP_NOT_APPRENTICE)
apprentice_remind_user.append(user['id'])
if import_remind_user:
async with db.conn.acquire() as con:
update_user = await con.prepare(
'''update "user" set need_remind = jsonb_set(need_remind, $1, $2::jsonb), update_date = now()
where id = any($3)''')
await update_user.fetchrow({"remind"}, '0', import_remind_user)
if apprentice_remind_user:
async with db.conn.acquire() as con:
update_user = await con.prepare(
'''update "user" set need_remind = jsonb_set(need_remind, $1, $2::jsonb), update_date = now()
where id = any($3)''')
await update_user.fetchrow({"remind"}, '0', apprentice_remind_user)
async def mass_message_detail(id):
async with db.conn.acquire() as con:
st = await con.prepare(
'''select group_ids::jsonb as "groups_info", content::jsonb, to_char(send_date, 'YYYY-MM-DD HH24:MI:SS') as send_date
from "group_task" where id=$1 and status<>3''')
group_task = await st.fetchrow(id)
if not group_task:
return
group_task = dict(group_task)
gst = await con.prepare(
'select id, name from "group" where code = any($1) and status <> 3'
)
group_codes = ujson.loads(group_task['groups_info'])
groups = await gst.fetch(group_codes)
group_task['groups_info'] = records_to_list(groups)
group_task['content'] = ujson.loads(group_task['content'])
return group_task
async def check_can_created_today(user_id, send_date):
async with db.conn.acquire() as con:
st = await con.prepare(
'''select to_char(send_date, 'YYYY-MM-DD') as day, count(1) as count from "group_task"
where user_id=$1 and status<>$2 and type = 1 group by to_char(send_date, 'YYYY-MM-DD')'''
)
day_group_count = records_to_list(await
st.fetch(user_id, FAIL_DELETE))
date = str_to_datetime(send_date)
if date <= datetime.now():
return False
str_date = date.strftime('%Y-%m-%d')
for item in day_group_count:
if item['day'] == str_date and item['count'] >= MAX_MASS_MSG_AMOUNT:
logger.info(
f'user [{user_id}] create mass msg max day [{str_date}]')
return False
return True
async def users_groups_settlement():
'''用户群结算统计'''
logger.info('start user groups settled...')
settle_groups = records_to_list(await need_settlement_groups())
logger.info(f'need settlement groups count: {len(settle_groups)}')
index = 0
settle_date = yesterday_date()
for user_code, items in await async_groupby(settle_groups, 'user_code'):
index += 1
copy_items = list(items)
try:
await signle_user_groups_settlement(user_code,
copy_items,
settle_date,
settle_type=TYPE.PULL_GROUP)
except Exception as e:
logger.error(f'user [{user_code} settle occer error: [{e}]]')
logger.info(f'include users count: {index}')
async def launch_history(request, **kwargs):
user_id = kwargs['user']['user_id']
current_page = int(request.raw_args.get('current_page'))
page_size = int(request.raw_args.get('page_size'))
logger.debug(f'launch history req, user_id:{user_id}')
async with db.conn.acquire() as con:
user_task_stmt = await con.prepare(
'''select id as task_id, to_char(send_date, 'YYYY-MM-DD HH24:MI:SS') as send_date, jsonb_array_length(group_ids)::varchar as group_count, status as send_flag from "group_task"
where user_id = $1 and type = 2 and status =1 and create_date >= (current_date - 2)
order by create_date desc limit $2 offset $3''')
user_tasks = await user_task_stmt.fetch(user_id, page_size,
current_page * page_size)
task_list = records_to_list(user_tasks)
history_count_stmt = await con.prepare(
'''select count(1) from "group_task" where user_id = $1 and type = 2 and status = 1 and create_date >= (current_date - 2)'''
)
total_records = await history_count_stmt.fetchval(user_id)
page_info = get_page_info(page_size, current_page, total_records)
return response_json(task_list, page_info=page_info)
async def problem_feedback(request, *args, **kwargs):
current_page = int(request.raw_args.get('current_page', 0))
page_size = int(request.raw_args.get('page_size', 20))
params = request.json
sql, sql_count = await problem_sql(params)
sql = sql + ''' limit ''' + str(page_size) + ''' offset ''' + str(
current_page * page_size)
async with db.conn.acquire() as con:
select_result = records_to_list(await con.fetch(sql))
select_count = await con.fetchval(sql_count)
for result in select_result:
if result['code'] is not None:
result['robot_info'] = result['name'] + '(' + result[
'wechat_no'] + ')'
page_info = get_page_info(page_size, current_page, select_count)
return response_json(select_result, page_info=page_info)
async def get_alt_msg(request, *args, **kwargs):
"""获取@用户机器人信息"""
user_id = kwargs['user']['user_id']
current_page = int(request.raw_args.get('current_page', 0))
page_size = int(request.raw_args.get('page_size', 20))
async with db.conn.acquire() as con:
select_altmsg = await con.prepare(
'''select "alt_msg".msg_id as msg_id, "group".name as group_name, "alt_msg".msg_content as msg_content,
"group".code as group_code, "alt_msg".status as status from "alt_msg" left join "group" on
"group".id="alt_msg".group_id where "group".status !=3 and "alt_msg".user_id = $1 and
"alt_msg".create_date >=(current_date - interval '3' day) order by "alt_msg".create_date desc
limit $2 offset $3''')
msg_infos = records_to_list(await select_altmsg.fetch(
user_id, page_size, current_page * page_size))
select_count = await con.prepare(
'''select count(1) from "alt_msg" left join "group" on "group".id="alt_msg".group_id
where "group".status !=3 and "alt_msg".user_id = $1 and "alt_msg".create_date >=(current_date - interval '3' day)'''
)
total_records = await select_count.fetchval(user_id)
page_info = get_page_info(page_size, current_page, total_records)
return response_json(msg_infos, page_info=page_info)
async def export_result(request, *args, **kwargs):
params = request.json
sql, sql_count = await withdraw_sql(params)
async with db.conn.acquire() as con:
select_result = records_to_list(await con.fetch(sql))
if not select_result:
return response_json(None)
title = ['phone', 'amount', 'create_date', 'paid_date', 'status']
out = io.BytesIO()
workbook = xlsxwriter.Workbook(out)
worksheet = workbook.add_worksheet()
for item in title:
worksheet.write(0, title.index(item), item)
for item in select_result:
worksheet.write(
select_result.index(item) + 1, 0,
item['phone'] if item['phone'] is not None else '')
worksheet.write(
select_result.index(item) + 1, 1,
item['amount'] if item['amount'] is not None else '')
worksheet.write(
select_result.index(item) + 1, 2,
item['create_date'] if item['create_date'] is not None else '')
worksheet.write(
select_result.index(item) + 1, 3,
item['paid_date'] if item['paid_date'] is not None else '')
worksheet.write(
select_result.index(item) + 1, 4,
item['status'] if item['status'] is not None else '')
workbook.close()
out.seek(0)
filename = quote("提现列表.xlsx")
return raw(out.getvalue(),
headers={
'Content-Disposition':
'attachment;filename*=utf-8{0}'.format(filename)
},
content_type='application/vnd.ms-excel;chartset=utf-8')
async def apprentice_remind(request, *args, **kwargs):
"""徒弟唤醒"""
user_id = request.json.get('user_id', None)
is_import = request.json.get('is_import', None)
is_apprentice = request.json.get('is_apprentice', None)
redis_awakening_key = APPRENTICE_REMID_REDIS_KEY + user_id
if await redis.conn.exists(redis_awakening_key):
return response_json(None, msg='当日提醒一次')
user_info = await get_user_by_id(user_id)
async with db.conn.acquire() as con:
select_stmt = await con.prepare(
'''select "robot".code from "robot" left join "robot_add_friend" on "robot".id = "robot_add_friend".robot_id
where "robot_add_friend".user_id = $1 and "robot_add_friend".status !=3'''
)
robot_codes = records_to_list(await select_stmt.fetch(user_id))
if not robot_codes:
return response_json(None, msg='机器人未找到', code=RESOURCE_NOT_FOUND_CODE)
if (is_import is not None and not is_import) or (not is_apprentice
and not is_import):
await send_msg(robot_codes, NOT_IMPORT_MSG, user_info['code'])
elif is_apprentice is not None and not is_apprentice:
await send_msg(robot_codes, NOT_APPRENTICE_MSG, user_info['code'])
await redis.conn.setex(redis_awakening_key, get_time(), 1)
return response_json(None)
