def login_by_wx_ticket(self):
"""微信扫描二维码登录"""
scene_id = self.args['scene_id']
wx_userinfo = pf_redis.get('pf_scene_openid:%s' % scene_id)
if not wx_userinfo:
return self.send_success(done=False)
wx_userinfo = json.loads(wx_userinfo.decode())
if len(str(scene_id)) == 9:
success, user_or_msg = AuthFunc.login_by_wx(
self.session, wx_userinfo)
if not success:
return self.send_fail(user_or_msg)
user = user_or_msg
self.set_current_user(user)
else:
return self.send_fail("scene_id 无效")
pf_redis.delete('pf_scene_openid:%s' % scene_id)
# 更新微信信息
AuthFunc.update_through_wx(self.session,
wx_userinfo,
user,
action="bind")
# 手机绑定状态
phone_bind = bool(user.phone)
return self.send_success(done=True, phone_bind=phone_bind)
def bind_phone(self):
"""绑定手机"""
code = self.args["code"]
phone = Emoji.filter_emoji(self.args["phone"].strip())
if not self.current_user:
return self.write_error(401)
if len(phone) != 11:
return self.send_fail("请填写正确的手机号")
check_msg_res = check_msg_token(phone, code, use="bind")
if not options.debug and not check_msg_res:
return self.send_fail("验证码过期或者不正确")
# 尝试合并账号
success, errmsg = AuthFunc.merge_passport(
self.session, self.current_user.passport_id, phone)
if success:
self.clear_current_user()
return self.send_success()
elif errmsg != "USE UPDATE":
return self.send_fail(errmsg)
# 尝试使用 UPDATE
success, errmsg = AuthFunc.update_passportinfo(
self.current_user.passport_id, "phone", phone)
if not success:
if errmsg == "NOT EXIST":
return self.send_fail("账户不存在，请联系森果客服 400-027-0135")
elif errmsg == "SAME VALUE":
return self.send_fail("无需重复绑定")
elif errmsg == "ALREADY BIND":
return self.send_fail("该手机号已绑定，请更换手机号绑定或联系森果客服 400-027-0135")
else:
return self.send_fail("绑定失败，请联系森果客服 400-027-0135")
self.current_user.phone = phone
# 更新门店联系人 ID
contacts = self.session.query(models.ShopContact) \
.filter(models.ShopContact.phone == phone) \
.all()
if contacts:
for contact in contacts:
contact.account_id = self.current_user.id
self.session.commit()
self.clear_current_user()
return self.send_success()
def post(self):
"""
前端wx.getUserInfo方法返回的用户信息:
{
user_info:用户信息对象，不包含 openid 等敏感信息
rawData:不包括敏感信息的原始数据字符串，用于计算签名
signature:使用 sha1( rawData + sessionkey ) 得到字符串，用于校验用户信息
encryptedData:包括敏感数据在内的完整用户信息的加密数据(包含unionid)
iv:加密算法的初始向量
}
source: 登录请求的来源 "purchase"-采购助手 "demand"-订货助手
"""
if self.current_user:
return self.send_fail("无需重复登录")
from handlers.applet import ResolveData
res_status, res_content = ResolveData().resolve(self.args)
if not res_status:
return self.send_fail(res_content)
user_info = res_content
success, user_or_msg = AuthFunc.login_by_wx(self.session, user_info)
if not success:
return self.send_fail(user_or_msg)
AuthFunc.update_through_wx(self.session,
user_info,
user_or_msg,
action="bind")
user = user_or_msg
self.set_current_user(user)
# 设置当前中转站
station = self.session.query(models.TransferStation) \
.join(models.Staff, models.Staff.station_id == models.TransferStation.id) \
.filter(models.TransferStation.status == 0,
models.Staff.status == 0,
models.Staff.account_id == user.id,
models.Staff.purchaser_status == 1) \
.first()
if station:
self.set_current_station_cookie(station.id,
domain=self._ARG_DEFAULT)
# #缓存session_key
# redis_name = "session_key:%s:%d"%(appid,customer_id)
# redis_session.set(redis_name,session_key,7*24*60*60)
phone_bind = bool(user.phone)
return self.send_success(phone_bind=phone_bind)
def bind_wx(self):
"""绑定微信"""
scene_id = self.args['scene_id']
wx_userinfo = pf_redis.get('pf_scene_openid:%s' % scene_id)
if not wx_userinfo:
return self.send_success(done=False)
wx_userinfo = json.loads(wx_userinfo.decode())
wx_unionid = wx_userinfo["unionid"]
# 绑定微信
if len(str(scene_id)) == 8:
bind_key = "ph_scene_bind_account:%s" % scene_id
bind_user_id = redis.get(bind_key) or -1
user = models.AccountInfo.get_by_id(self.session, bind_user_id)
# scene_id 不对或者 Redis 的 key 过期了
if not user or not user.passport_id:
return self.send_fail("请刷新页面后重试")
success, errmsg = AuthFunc.update_passportinfo(
user.passport_id, "wx_unionid", wx_unionid)
if not success:
if errmsg == "NOT EXIST":
return self.send_fail("账户不存在，请联系森果客服 400-027-0135")
elif errmsg == "SAME VALUE":
# 重复绑定是为了取微信信息
pass
elif errmsg == "ALREADY BIND":
return self.send_fail("该微信已被其他账户绑定")
else:
return self.send_fail("绑定失败，请联系森果客服 400-027-0135")
redis.delete(bind_key)
else:
return self.send_fail("scene_id 无效")
pf_redis.delete('pf_scene_openid:%s' % scene_id)
redis.delete("ph_scene_bind_account:%s" % scene_id)
# 更新微信信息
AuthFunc.update_through_wx(self.session,
wx_userinfo,
user,
action="bind")
return self.send_success(done=True)
def confirm(self, order):
api = GetPifaData(self.current_user.passport_id, AuthFunc.gen_token())
ret_dict = api.confirm_pf_demand_order(self.current_user.phone,
order.object_id, order.id)
if not ret_dict["success"]:
return self.send_fail(ret_dict.get("msg", ""))
return self.send_success()
def post(self):
code = self.args["code"]
wx_userinfo = WxOauth2.get_userinfo(code, mode="")
if not wx_userinfo:
return self.send_error(401)
success, user_or_msg = AuthFunc.login_by_wx(self.session, wx_userinfo)
if not success:
return self.send_error(403, error_msg=user_or_msg)
user = user_or_msg
self.set_current_user(user_or_msg)
# 更新微信信息
AuthFunc.update_through_wx(self.session,
wx_userinfo,
user,
action="bind")
# 手机绑定状态
phone_bind = bool(user.phone)
return self.send_success(phone_bind=phone_bind)
def login_by_phone_code(self):
"""
手机号+验证码登录，已注册用户直接登录，未注册用户生成新账号并登录
phone:手机号
code:验证码
"""
phone = self.args["phone"].strip()
code = self.args["code"].strip()
if len(phone) != 11:
return self.send_fail("请填写正确的手机号")
check_msg_res = check_msg_token(phone, code, use="login")
if not options.debug and not check_msg_res:
return self.send_fail("验证码错误或已失效")
# 登录
success, user_or_msg = AuthFunc.login_by_phone_code(
self.session, phone)
if not success:
return self.send_fail(user_or_msg)
# 设置cookie
self.set_current_user(user_or_msg)
# 返回微信绑定状态，三者缺一要求重新绑定
if user_or_msg.wx_unionid and user_or_msg.nickname and user_or_msg.headimgurl:
wx_bind = True
else:
wx_bind = False
# 更新门店联系人 ID
contacts = self.session.query(models.ShopContact) \
.filter(models.ShopContact.phone == phone) \
.all()
if contacts:
for contact in contacts:
contact.account_id = user_or_msg.id
self.session.commit()
return self.send_success(wx_bind=wx_bind)
def get(self):
api = GetPifaData(self.current_user.passport_id, AuthFunc.gen_token())
ret_dict = api.get_pf_shops(self.current_user.phone)
if not ret_dict["success"]:
return self.send_fail(ret_dict.get("msg", ""))
data_list = []
for data in ret_dict["data_list"]:
data_list.append({
"shop_id":
check_int(PfSimpleEncrypt.decrypt(data.get("shop_id", 0))),
"shop_name":
data.get("shop_name", ""),
"purchase_times":
data.get("purchase_times", 0),
"latest_order_time":
data.get("latest_order_time", ""),
"is_online_order_open":
data.get("is_online_order_open", 0),
})
return self.send_success(data_list=data_list)
def post(self):
name = self.args["name"]
city_code = self.args["city_code"]
address = self.args["address"]
phone = self.args["phone"]
code = self.args["code"]
province_code = ProvinceCityFunc.city_to_province(city_code)
if not province_code:
return self.send_fail("请填写正确的省份")
if len(phone) != 11:
return self.send_fail("请填写正确的手机号")
check_msg_res = check_msg_token(phone, code, use="station_register")
if not options.debug and not check_msg_res:
return self.send_fail("验证码过期或者不正确")
# 检查用于注册的手机号
success, errmsg = AuthFunc.update_passportinfo(
self.current_user.passport_id, "phone", phone)
if not success:
if errmsg == "NOT EXIST":
return self.send_fail("请登录后重试")
elif errmsg == "SAME VALUE":
pass
elif errmsg == "ALREADY BIND":
return self.send_fail("该手机号已被注册")
self.current_user.phone = phone
existed_station = self.session.query(models.TransferStation) \
.join(models.Staff, models.Staff.station_id == models.TransferStation.id) \
.filter(models.Staff.super_admin_status == 1,
models.Staff.status == 0,
models.Staff.account_id == self.current_user.id) \
.first()
if existed_station:
return self.send_fail("您已经是 {} 的超级管理员了".format(
existed_station.name))
# 添加新中转站
new_station = models.TransferStation(
name=name,
province=province_code,
city=city_code,
address=address,
creator_id=self.current_user.id,
)
self.session.add(new_station)
self.session.flush()
# 添加默认超管
super_admin = models.Staff(
station_id=new_station.id,
account_id=self.current_user.id,
super_admin_status=1,
admin_status=1,
purchaser_status=0,
date_onboarding=datetime.date.today(),
)
super_admin.set_admin_permissions(None, grant_all=True)
super_admin.set_purchaser_permissions(None, grant_all=True)
self.session.add(super_admin)
# 添加设置项
config = models.Config(id=new_station.id)
self.session.add(config)
self.session.commit()
self.clear_current_user()
return self.send_success()
def post(self):
pf_shop_id = self.args["pf_shop_id"]
pf_shop_name = self.args["pf_shop_name"]
demand_date = self.args["demand_date"]
goods_list = self.args["goods_list"]
valid, message = self.validate_goods_list(goods_list)
if not valid:
return self.send_fail(message)
# 添加到本地数据库
new_order = models.ExternalDemandOrder(
creator_id=self.current_user.id,
target=1,
object_id=pf_shop_id,
object_name=pf_shop_name,
demand_date=demand_date,
)
self.session.add(new_order)
self.session.flush()
demand_list = []
for goods_data in goods_list:
goods_name = goods_data["goods_name"]
demand_amount = check_float(goods_data["demand_amount"])
demand_unit = check_int(goods_data["demand_unit"])
remarks = goods_data.get("remarks", "")
new_order_goods = models.ExternalDemandOrderGoods(
creator_id=self.current_user.id,
order_id=new_order.id,
goods_name=goods_name,
demand_amount=check_int(demand_amount * 100),
demand_unit=demand_unit,
remarks=remarks,
)
self.session.add(new_order_goods)
self.session.flush()
unit_map = {
0: "斤",
1: "件",
2: "kg",
3: "个",
4: "份",
5: "盒",
6: "只",
7: "包"
}
demand_list.append({
"external_line_id": new_order_goods.id,
"name": goods_name,
"amount": demand_amount,
"unit_text": unit_map.get(demand_unit, "斤"),
"remark": remarks,
})
api = GetPifaData(self.current_user.passport_id, AuthFunc.gen_token())
ret_dict = api.send_pf_demand_order(self.current_user.phone,
pf_shop_id, new_order.id,
demand_date, demand_list)
if not ret_dict["success"]:
return self.send_fail(ret_dict.get("msg", ""))
self.session.commit()
return self.send_success()
def get(self, order_id):
order = self.session.query(models.ExternalDemandOrder) \
.filter(models.ExternalDemandOrder.id == order_id,
models.ExternalDemandOrder.creator_id == self.current_user.id) \
.first()
if not order:
return self.send_fail("没有找到该订货单")
goods_list = order.goods_list.all()
# 从批发获取订单详情
api = GetPifaData(self.current_user.passport_id, AuthFunc.gen_token())
ret_dict = api.get_pf_demand_order(self.current_user.phone,
order.object_id, order.id)
if not ret_dict["success"]:
return self.send_fail(ret_dict.get("msg", ""))
pf_order_data = ret_dict.get("data", {})
pf_goods_dict = {
goods_data.get("external_id"): goods_data
for goods_data in pf_order_data.get("demand_lines", [])
}
demand_goods_list = []
for goods in goods_list:
# 同步批发订单信息
pf_goods = pf_goods_dict.get(goods.id)
if not goods.syncronized and pf_goods:
sale_record_info = pf_goods.get("sale_record_info", {})
goods.confirmed_amount = check_int(
sale_record_info.get("amount", 0) * 100)
goods.confirmed_unit = check_int(
sale_record_info.get("unit", 0))
goods.price = check_int(
sale_record_info.get("unit_price", 0) * 100)
goods.total_money = check_int(
sale_record_info.get("sales_money", 0) * 100)
# goods.syncronized = 1
demand_goods_list.append({
"id":
goods.id,
"goods_name":
goods.goods_name,
"demand_amount":
check_float(goods.demand_amount / 100),
"demand_unit":
goods.demand_unit,
"remarks":
goods.remarks,
"confirmed_amount":
check_float(goods.confirmed_amount / 100),
"confirmed_unit":
goods.confirmed_unit,
"price":
check_float(goods.price / 100),
"total_money":
check_float(goods.total_money / 100),
})
data = {
"shop_id": order.object_id,
"shop_name": order.object_name,
"demand_date": TimeFunc.time_to_str(order.demand_date, "date"),
"create_time": TimeFunc.time_to_str(order.create_time),
"status": order.status,
"total_money":
check_float(pf_order_data.get("order_money", 0) / 100),
"goods_list": demand_goods_list,
}
self.session.commit()
return self.send_success(data=data)