async def service_detail(request, service_id):
actor = request["session"]["st_token"]
actor_id = actor["id"]
with yhk_session() as session:
# 获取服务详情，服务套餐中排除不可用以及不可重复购买的套餐
service = await Service.get(session, service_id)
if not service.enable or service.delete_flag:
return html(await render_template("500.html",
request=request,
message="服务不可用！"))
# 获取标价套餐
service.package = await Package.get_service_marked_price(
session, service.id)
# 获取可售套餐
packages = []
for pk in service.packages:
if pk.enable:
if pk.can_buy_again:
packages.append(pk)
else:
buying_log = await ServicePackageBuyingLog.check_can_buy_again(
session, actor_id, pk.id)
if not buying_log: # 未购买过此套餐
packages.append(pk)
return html(await render_template("member/shop_service.html",
request=request,
item=service,
packages=packages))
async def login(request):
if request.method == "GET":
return html(await render_template('/member/login.html',
request=request))
username = request.form.get("username") # 手机号
password = request.form.get("password") # 密码，md5加密
valid_code = request.form.get("valid_code") # 验证码
if not (username and password and valid_code):
return json({"code": 500, "message": "请填写登录信息！"})
if not tools.test_mobile(username):
return json({"code": 500, "message": "手机号码格式错误！"})
session_valid_code = request["session"]["valid_code"]
if len(valid_code) > 4 or session_valid_code != valid_code.upper():
return json({"code": 500, "message": "验证码错误！"})
with yhk_session() as session:
actor = await Actor.get_by_phone(session, username)
if not actor:
return json({"code": 500, "message": "用户名或密码错误！"})
encrypt_pwd = hashlib.md5(
f"{username}:{password}".encode("utf-8")).hexdigest()
if actor.password != encrypt_pwd:
return json({"code": 500, "message": "用户名或密码错误！"})
if actor.is_locked:
return json({"code": 500, "message": "账户已锁定，请联系管理员！"})
request["session"]["st_token"] = actor.to_json()
return json({"code": 200, "message": "登录成功！"})
async def member_service(request, actor_id):
with yhk_session() as session:
actor = await Actor.get(session, actor_id)
datalist = await ActorService.get_member_services(session, actor_id)
return html(await render_template('/admin/member_service.html',
request=request,
actor=actor,
datalist=datalist))
async def view(request, service_id):
with yhk_session() as session:
service = await Service.get(session, service_id)
service.service_type = constants.SERVICE_TYPE_DICT.get(
service.service_type)
return html(await render_template('/admin/service_view.html',
request=request,
data=service))
async def delete_service(request, service_id):
with yhk_session() as session:
service = await Service.get(session, service_id)
if not service:
return json({"code": 500, "message": "删除失败，服务不存在！"})
service.delete_flag = True
session.commit()
return json({"code": 200, "message": "删除成功！"})
async def shop_index(request):
with yhk_session() as session:
services = await Service.get_all(session)
for s in services:
s.package = await Package.get_service_marked_price(session, s.id)
return html(await render_template("member/shop.html",
request=request,
datalist=services))
async def get_member_list(request, actor_id):
with yhk_session() as session:
actor = await Actor.get(session, actor_id)
if not actor:
return json({"code": 500, "message": "会员信息不存在！"})
actor.is_locked = not actor.is_locked
session.commit()
return json({"code": 200, "message": "操作成功！"})
async def get_order_list(request, order_id):
payment_type = request.form.get("payment_type")
payment_price = request.form.get("payment_price")
payment_time = request.form.get("payment_time")
if not (payment_type and payment_price and payment_time):
return json({"code": 500, "message": "参数错误，请填写完整信息！"})
payment_type = int(payment_type)
payment_price = float(payment_price)
payment_time = datetime.datetime.strptime(payment_time,
"%Y-%m-%d %H:%M:%S")
with yhk_session() as session:
# 修改订单支付信息，并增加相应服务次数
order = await ServiceOrder.get(session, order_id)
if not order.service or not order.package:
return json({"code": 500, "message": "订单服务套餐不存在！"})
if order.payment_status != constants.PAYMENT_STATUS_UNPAYED and order.order_status != constants.ORDER_STATUS_CONFIRM:
return json({"code": 500, "message": "订单已支付，不能重复审核！"})
if order.package.service_id != order.service_id:
return json({"code": 500, "message": "订单服务和套餐不匹配！"})
if not order.package.can_buy_again:
buying_log = await ServicePackageBuyingLog.check_can_buy_again(
session, order.actor_id, order.package_id)
if buying_log:
return json({"code": 500, "message": "此用户已购买过此套餐，不可重复购买！"})
now = datetime.datetime.now()
order.payment_price = payment_price # 实际支付金额
order.payment_time = payment_time
order.payment_status = constants.PAYMENT_STATUS_PAYED # 支付状态 1：未支付，2：已支付，3：已退款
order.payment_type = payment_type
# 创建购买记录
log = ServicePackageBuyingLog()
log.actor_id = order.actor_id
log.service_id = order.service.id
log.package_id = order.package_id
log.payment_price = payment_price
log.service_order_id = order_id
log.created_time = now
session.add(log)
# 添加我的服务信息
actor_service = await ActorService.get_my_service(
session, order.actor_id, order.service_id)
if actor_service:
actor_service.last_buy_time = now
actor_service.package_time += order.package.times
else:
actor_service = ActorService()
actor_service.actor_id = order.actor_id
actor_service.service_id = order.service_id
actor_service.service_name = order.service.service_name
actor_service.last_buy_time = now
actor_service.package_time = order.package.times
actor_service.created_time = now
session.add(actor_service)
session.commit()
return json({"code": 200, "message": "审核成功！"})
async def service_package_delete(request, package_id):
with yhk_session() as session:
package = await Package.get(session, package_id)
if not package:
return json({"code": 4001, "message": "当前套餐不存在！"})
package.delete_flag = True
session.commit()
return json({"code": 200, "message": "删除成功！"})
async def login(request):
actor = request["session"]["st_token"]
actor_id = actor["id"]
with yhk_session() as session:
actor = await Actor.get(session, actor_id)
services = actor.services
return html(await render_template("member/my_service.html",
request=request,
datalist=services))
async def task_save(request, task_type):
actor = request["session"]["st_token"]
actor_id = actor["id"]
task_name = request.form.get("task_name")
if not task_name:
return json({"code": 500, "message": "请填写任务名称！"})
if task_type == constants.SERVICE_TYPE_BAIDU_PC_TOP50:
keywords = request.form.get("keywords")
if not keywords:
return json({"code": 500, "message": "请填写关键词！"})
keywords = keywords.strip("\n").replace("\n", "|")
keywords_arr = keywords.split("|")
times = len(keywords_arr)
if times > 50:
return json({"code": 500, "message": "关键词最多50个！"})
task_count = request.form.get("task_count")
if task_count:
task_count = int(task_count)
if task_count > 100:
return json({"code": 500, "message": "查询结果最多返回前100名！"})
with yhk_session() as session:
# 检查是否拥有此服务权限
actor_service = await ActorService.get_service_by_type(session, actor_id, task_type)
if not actor_service:
return json({"code": 401, "message": "抱歉，没有服务权限，请先购买此服务！"})
# 检查服务次数是否足够
if actor_service.package_time < times:
return json({"code": 500, "message": "抱歉，服务调用次数不足，请先购买！"})
# 首先扣除服务次数
old_times = actor_service.package_time
actor_service.package_time = actor_service.package_time - times
session.commit()
# 创建任务
task = await Task.create_task(session, actor_id, task_name, actor_service.service_id, task_type)
await BaiduPcTop50Condition.create_condition(session, task.id, keywords, task_count)
# 记录使用记录
await ServiceConsumeLog.log(session, actor_id, actor_service.service_id, -times, old_times,
actor_service.package_time,
"创建查询任务扣减", task.id)
# 启动任务
out_task_id, result, code = baidu_keyword_rank_pc.create_task(keywords, task_count)
if code == 0:
task.task_status = constants.TASK_STATUS_START
else:
task.task_status = constants.TASK_STATUS_FAIL
# 将服务次数加回来
old_times = actor_service.package_time
actor_service.package_time = actor_service.package_time + times
await ServiceConsumeLog.log(session, actor_id, actor_service.service_id, times,
old_times, actor_service.package_time,
"任务执行失败，返还调用次数", task.id)
task.out_task_id = out_task_id
task.task_result = result
session.commit()
return json({"code": 200, "message": "创建成功！"})
return json({"code": 500, "message": "此类型服务暂不支持！"})
async def task_delete(request, task_id):
actor = request["session"]["st_token"]
actor_id = actor["id"]
with yhk_session() as session:
task = await Task.get(session, task_id)
if not task:
return json({"code": 500, "message": "任务不存在！"})
if task.actor_id != actor_id:
return json({"code": 401, "message": "没有权限，此任务不属于你！"})
task.delete_flag = True
session.commit()
return json({"code": 200, "message": "删除成功！"})
async def get_member_list(request):
offset = request.args.get("offset")
limit = request.args.get("limit")
phone = request.args.get("phone")
if offset:
offset = int(offset)
if limit:
limit = int(limit)
with yhk_session() as session:
data, total = await Actor.query(session, phone, offset, limit)
actors = [actor.to_json() for actor in data]
return json({"rows": actors, "total": total})
async def service_package_save(request):
service_id = request.form.get("service_id")
package_id = request.form.get("package_id")
package_name = request.form.get("package_name")
package_price = request.form.get("package_price")
times = request.form.get("times")
package_type = request.form.get("package_type")
order_no = request.form.get("order_no")
if not (service_id and package_name and package_price and times
and package_type and order_no):
return json({"code": 500, "message": "请填写完整信息！"})
remark = request.form.get("remark")
can_buy_again = request.form.get("can_buy_again")
is_marked_price = request.form.get("is_marked_price")
enable = request.form.get("enable")
service_id = int(service_id)
if package_id:
package_id = int(package_id)
package_price = float(package_price)
times = int(times)
package_type = int(package_type)
order_no = int(order_no)
can_buy_again = bool(can_buy_again)
is_marked_price = bool(is_marked_price)
enable = bool(enable)
with yhk_session() as session:
if not package_id:
package = Package()
package.service_id = service_id
session.add(package)
else:
package = await Package.get(session, package_id)
if not package:
return json({"code": 4001, "message": "当前套餐不存在！"})
package.package_name = package_name
package.package_price = package_price
package.times = times
package.package_type = package_type
package.remark = remark
package.can_buy_again = can_buy_again
package.is_marked_price = is_marked_price
package.enable = enable
package.order_no = order_no
session.commit()
return json({
"code": 200,
"message": "保存成功！",
"package_id": package.id
})
async def task_create(request):
actor = request["session"]["st_token"]
actor_id = actor["id"]
service_id = request.args.get("service_id")
with yhk_session() as session:
services = await ActorService.get_member_services(session, actor_id)
return html(
await render_template(
"member/task_create.html",
request=request,
services=services,
service_id=service_id
)
)
async def get_service_list(request):
offset = request.args.get("offset")
limit = request.args.get("limit")
service_name = request.args.get("service_name")
if offset:
offset = int(offset)
if limit:
limit = int(limit)
with yhk_session() as session:
data, total = await Service.query(session, service_name, offset, limit)
items = []
for item in data:
service = item.to_json()
service["category_name"] = item.category.category_name
items.append(service)
return json({"rows": items, "total": total})
async def sms_send(request):
phone = request.form.get("phone") # 手机号
if not phone:
return json({"code": 500, "message": "手机号码为空！"})
if not test_mobile(phone):
return json({"code": 500, "message": "手机号码不正确！"})
# 1.检查手机号是否已经注册过
with yhk_session() as session:
actor = await Actor.get_by_phone(session, phone)
if actor:
return json({"code": 500, "message": "手机号码已注册！"})
msg_id = Jpush().send_sms_txt_codes(phone) # "354838553987"
if not msg_id:
return json({"code": 500, "message": "获取验证码失败！"})
request["session"]["sms_code_id"] = msg_id
return json({"code": 200, "message": "发送成功！"})
async def task_list(request):
actor = request["session"]["st_token"]
actor_id = actor["id"]
offset = request.args.get("offset")
limit = request.args.get("limit")
task_name = request.args.get("task_name")
if offset:
offset = int(offset)
if limit:
limit = int(limit)
with yhk_session() as session:
total, tasks = await Task.query(session, actor_id, task_name, offset, limit)
rows = [await task.to_json(session) for task in tasks]
return json({"rows": rows, "total": total})
async def consume_log_list(request, service_id):
actor = request["session"]["st_token"]
actor_id = actor["id"]
offset = request.args.get("offset")
limit = request.args.get("limit")
if offset:
offset = int(offset)
if limit:
limit = int(limit)
with yhk_session() as session:
total, logs = await ServiceConsumeLog.query(session, actor_id,
service_id, offset, limit)
rows = [log.to_json() for log in logs]
return json({"rows": rows, "total": total})
async def get_order_list(request):
offset = request.args.get("offset")
limit = request.args.get("limit")
phone = request.args.get("phone")
if offset:
offset = int(offset)
if limit:
limit = int(limit)
with yhk_session() as session:
data, total = await ServiceOrder.query(session, phone, offset, limit)
orders = []
for item in data:
order_status = int(f'{item.order_status}{item.payment_status}')
orders.append({
"id":
item.id,
"actor_id":
item.actor_id,
"service_id":
item.service_id,
"package_id":
item.package_id,
"actor_phone":
item.actor.phone,
"service_name":
item.service.service_name,
"package_name":
item.package.package_name,
"package_price":
item.package.package_price,
"package_times":
item.package.times,
"payment_type":
constants.PAYMENT_TYPE_MAP.get(item.payment_type),
"payment_price":
item.payment_price,
"payment_time":
item.payment_time.strftime('%Y-%m-%d %H:%M:%S')
if item.payment_time else None,
"order_status":
order_status,
"order_status_text":
constants.ORDER_STATUS_MAP.get(order_status),
"created_time":
item.created_time.strftime('%Y-%m-%d %H:%M:%S')
})
return json({"rows": orders, "total": total})
async def task_result(request, task_id):
actor = request["session"]["st_token"]
actor_id = actor["id"]
with yhk_session() as session:
task = await Task.get(session, task_id)
service_type = constants.SERVICE_TYPE_BAIDU_PC_TOP50
if task:
if task.actor_id != actor_id:
task = None
else:
service_type = task.service_type
return html(
await render_template(
f"member/task_result_{service_type}.html",
request=request,
task=task
)
)
async def task_result_list(request, task_type, task_id):
actor = request["session"]["st_token"]
actor_id = actor["id"]
offset = request.args.get("offset")
limit = request.args.get("limit")
if offset:
offset = int(offset)
if limit:
limit = int(limit)
with yhk_session() as session:
task = await Task.get(session, task_id)
if not task or (task.actor_id != actor_id):
return json({"rows": [], "total": 0})
if task_type == constants.SERVICE_TYPE_BAIDU_PC_TOP50:
keyword = request.args.get("keyword")
total, rows = await BaiduPcTop50Result.query(session, task_id, keyword, offset, limit)
rows = [item.to_json() for item in rows]
return json({"rows": rows, "total": total})
async def task_save(request, task_id):
actor = request["session"]["st_token"]
actor_id = actor["id"]
with yhk_session() as session:
task = await Task.get(session, task_id)
condition = None
service_type = constants.SERVICE_TYPE_BAIDU_PC_TOP50
if task:
if task.actor_id != actor_id:
task = None
else:
task.task_status_text = constants.TASK_STATUS_DICT.get(task.task_status)
if task.service_type == constants.SERVICE_TYPE_BAIDU_PC_TOP50:
condition = await BaiduPcTop50Condition.get(session, task_id)
service_type = task.service_type
return html(
await render_template(
f"member/task_view_{service_type}.html",
request=request,
task=task,
condition=condition
)
)
async def login(request):
if request.method == "GET":
return html(await render_template('/admin/login.html',
request=request))
username = request.form.get("username") # 手机号
password = request.form.get("password") # 密码，md5加密
if not (username and password):
return json({"code": 500, "message": "请填写登录信息！"})
if len(username) < 6 or len(username) > 10:
return json({"code": 500, "message": "用户名或密码错误！"})
if len(password) != 32:
return json({"code": 500, "message": "用户名或密码错误！"})
with yhk_session() as session:
user = await SysUser.get_by_username(session, username)
if not user:
return json({"code": 500, "message": "用户名或密码错误！"})
encrypt_pwd = hashlib.md5(
f"{username}:{password}".encode("utf-8")).hexdigest()
if user.password != encrypt_pwd:
return json({"code": 500, "message": "用户名或密码错误！"})
request["session"]["st_admin_token"] = user.to_json()
return json({"code": 200, "message": "登录成功！"})
async def register(request):
if request.method == "GET":
return html(await render_template('/member/register.html', request=request))
username = request.form.get("username") # 手机号
password = request.form.get("password") # 密码，md5加密
confirm_password = request.form.get("confirm_password") # 密码，md5加密
sms_code = request.form.get("sms_code")
if not (username and password and confirm_password and sms_code):
return json({"code": 500, "message": "请填写完成信息！"})
if not test_mobile(username):
return json({"code": 500, "message": "手机号码不正确！"})
if password != confirm_password:
return json({"code": 500, "message": "两次密码不一致！"})
if len(sms_code) > 10:
return json({"code": 500, "message": "验证码长度不可超过10位！"})
msg_id = request["session"].get("sms_code_id")
if not msg_id:
return json({"code": 500, "message": "验证码错误！"})
valid_sms_code = Jpush().valid_sms_txt_codes(msg_id, sms_code)
if not valid_sms_code:
return json({"code": 500, "message": "验证码不正确！"})
with yhk_session() as session:
actor = await Actor.get_by_phone(session, username)
if actor:
return json({"code": 500, "message": "手机号码已注册！"})
src_pwd = f"{username}:{password}".encode("utf-8")
encrypt_pwd = hashlib.md5(src_pwd).hexdigest()
actor = Actor()
actor.phone = username
actor.password = encrypt_pwd
session.add(actor)
session.commit()
return json({"code": 200, "message": "注册成功！"})
async def task_result_list(request, task_type, task_id):
actor = request["session"]["st_token"]
actor_id = actor["id"]
with yhk_session() as session:
task = await Task.get(session, task_id)
if not task or (task.actor_id != actor_id):
return json({"rows": [], "total": 0})
if task_type == constants.SERVICE_TYPE_BAIDU_PC_TOP50:
keyword = request.args.get("keyword")
total, rows = await BaiduPcTop50Result.query(session, task_id, keyword)
# 生成excel
workbook = xlwt.Workbook(encoding='utf-8')
worksheet = workbook.add_sheet(task.task_name)
worksheet.write(0, 0, label='关键词')
worksheet.write(0, 1, label='排名')
worksheet.write(0, 2, label='网址')
worksheet.write(0, 3, label='页面地址')
worksheet.write(0, 4, label='页面标题')
worksheet.write(0, 5, label='权重')
worksheet.write(0, 6, label='top100')
for index, item in enumerate(rows):
row = index + 1
worksheet.write(row, 0, label=item.keyword)
worksheet.write(row, 1, label=item.rank)
worksheet.write(row, 2, label=item.site_url)
worksheet.write(row, 3, label=item.page_url)
worksheet.write(row, 4, label=item.page_title)
worksheet.write(row, 5, label=item.weight)
worksheet.write(row, 6, label=item.top100)
stream = io.BytesIO()
workbook.save(stream)
bytes = stream.getvalue()
headers = {'Content-Disposition': 'attachment;filename=%s.xls' % time.strftime('%Y%m%d%H%M%S')}
response = HTTPResponse(body_bytes=bytes, headers=headers, content_type='application/vnd.ms-excel')
return response
async def service_edit(request):
if request.method == "GET":
service_id = request.args.get("service_id")
service_types = constants.SERVICE_TYPE_DICT
with yhk_session() as session:
categories = await Category.get_all(session)
if not service_id:
return html(await render_template('/admin/service_edit.html',
request=request,
data=None,
categories=categories,
service_types=service_types))
else:
service = await Service.get(session, service_id)
service.packages = list(
filter(lambda p: p.delete_flag is False, service.packages))
return html(await render_template('/admin/service_edit.html',
request=request,
data=service,
categories=categories,
service_types=service_types))
elif request.method == "POST":
service_id = request.form.get("service_id")
service_name = request.form.get("service_name")
sub_heading = request.form.get("sub_heading")
price = request.form.get("price")
enable = request.form.get("enable")
category_id = request.form.get("category_id")
order_no = request.form.get("order_no")
remark = request.form.get("remark")
instruction = request.form.get("instruction")
service_type = request.form.get("service_type")
if not (service_name and sub_heading and price and enable
and category_id and order_no and instruction and service_type):
return json({"code": 500, "message": "请填写完整信息！"})
if service_id:
service_id = int(service_id)
category_id = int(category_id)
order_no = int(order_no)
price = float(price)
enable = True if enable == "true" else False
with yhk_session() as session:
if not service_id:
service = Service()
session.add(service)
else:
service = await Service.get(session, service_id)
if not service:
return json({"code": 4001, "message": "当前服务不存在！"})
service.service_name = service_name
service.sub_heading = sub_heading
service.price = price
service.enable = enable
service.category_id = category_id
service.order_no = order_no
service.remark = remark
service.instruction = instruction
service.service_type = service_type
session.commit()
return json({
"code": 200,
"message": "保存成功！",
"service_id": service.id
})
async def service_detail(request, service_id, package_id):
actor = request["session"]["st_token"]
actor_id = actor["id"]
with yhk_session() as session:
service = await Service.get(session, service_id)
if not service:
return json({"code": 500, "message": "服务信息异常，请联系客服！"})
package = await Package.get(session, package_id)
if not package or not package.enable:
return json({"code": 500, "message": "服务信息异常，请联系客服！"})
if package.service_id != service_id:
return json({"code": 500, "message": "服务信息异常，请联系客服！"})
if not package.can_buy_again:
buying_log = await ServicePackageBuyingLog.check_can_buy_again(
session, actor_id, package_id)
if buying_log:
return json({"code": 500, "message": "您已购买过此套餐，不可重复购买！"})
code = 200
now = datetime.datetime.now()
service_order = ServiceOrder()
service_order.actor_id = actor_id # 用户id
service_order.service_id = service_id # 服务id
service_order.package_id = package_id # 套餐id
service_order.order_status = constants.ORDER_STATUS_CONFIRM # 订单状态 1：已确认，2：已取消，3：已退货
if package.package_type == constants.SERVICE_PACKAGE_TYPE_FREE:
service_order.payment_type = constants.PAYMENT_TYPE_FREE
service_order.payment_price = package.package_price # 实际支付金额
service_order.payment_time = now
service_order.payment_status = constants.PAYMENT_STATUS_PAYED # 支付状态 1：未支付，2：已支付，3：已退款
else:
service_order.payment_status = constants.PAYMENT_STATUS_UNPAYED # 支付状态 1：未支付，2：已支付，3：已退款
session.add(service_order)
session.commit()
if package.package_type == constants.SERVICE_PACKAGE_TYPE_FREE:
# 创建购买记录
log = ServicePackageBuyingLog()
log.actor_id = actor_id
log.service_id = service_id
log.package_id = package_id
log.payment_price = package.package_price
log.service_order_id = service_order.id
log.created_time = now
session.add(log)
session.commit()
# 添加我的服务信息
actor_service = await ActorService.get_my_service(
session, actor_id, service_id)
if actor_service:
actor_service.last_buy_time = now
actor_service.package_time += package.times
else:
actor_service = ActorService()
actor_service.actor_id = actor_id
actor_service.service_id = service_id
actor_service.service_name = service.service_name
actor_service.last_buy_time = now
actor_service.package_time = package.times
actor_service.created_time = now
session.add(actor_service)
session.commit()
code = 2001
return json({
"code": code,
"data": {
"service_name": service.service_name,
"package_name": package.package_name,
"package_price": package.package_price,
"times": package.times
}
})
