def close_order(self, pay_order_id=0):
if pay_order_id < 1:
return False
pay_order_info = PayOrder.query.filter_by(id=pay_order_id,
status=-8).first()
if not pay_order_info:
return False
pay_order_items = PayOrderItem.query.filter_by(
pay_order_id=pay_order_id).all()
if pay_order_items:
#需要归还库存
for item in pay_order_items:
tmp_food_info = Food.query.filter_by(id=item.food_id).first()
if tmp_food_info:
tmp_food_info.stock = tmp_food_info.stock + item.quantity
tmp_food_info.updated_time = get_current_date()
with db.auto_commit():
tmp_food_info
PayService.set_stock_change_log(item.food_id,
item.quantity, '订单取消')
pay_order_info.status = 0
pay_order_info.updated_time = get_current_date()
with db.auto_commit():
pay_order_info
return True
def my_address_set():
form = AddressForm().validate_for_api()
member_info = g.user
if not member_info:
return ParameterException('系统繁忙，请稍后再试')
address_info = MemberAddress.query.filter_by(
id=form.id.data, member_id=member_info.uid).first()
if address_info:
model_address = address_info
else:
default_address_count = MemberAddress.query.filter_by(
is_default=1, member_id=member_info.uid, status=1).count()
model_address = MemberAddress()
model_address.member_id = member_info.uid
model_address.is_default = 1 if default_address_count == 0 else 0
model_address.created_time = get_current_date()
model_address.nickname = form.nickname.data
model_address.mobile = form.mobile.data
model_address.address = form.address.data
model_address.province_id = form.province_id.data
model_address.province_str = form.province_str.data
model_address.city_id = form.city_id.data
model_address.city_str = form.city_str.data
model_address.area_id = form.district_id.data
model_address.area_str = form.district_str.data
model_address.updated_time = get_current_date()
with db.auto_commit():
db.session.add(model_address)
return Success()
def category_set():
if request.method == "GET":
resp_data = {}
req = request.args
c_id = int(req.get("id", 0))
c_info = None
if c_id:
c_info = FoodCategory.query.filter_by(id=c_id).first()
resp_data['info'] = c_info
resp_data['current'] = 'category'
return render_template("food/category_set.html", **resp_data)
req = request.values
c_id = req['id'] if 'id' in req else 0
name = req['name'] if 'name' in req else ''
weight = int(req['weight']) if ('weight' in req
and int(req['weight']) > 0) else 1
if name is None or len(name) < 1:
return AjaxFail('请输入符合规范的分类名称')
food_category_info = FoodCategory.query.filter_by(id=c_id).first()
if food_category_info:
model_food_category = food_category_info
else:
model_food_category = FoodCategory()
model_food_category.created_time = get_current_date()
model_food_category.name = name
model_food_category.weight = weight
model_food_category.updated_time = get_current_date()
with db.auto_commit():
db.session.add(model_food_category)
return AjaxSuccess()
def __login_by_mina(code):
openid = MemberService.get_wechat_openid(code)
if openid is None:
raise ServerError(msg='调用微信出错', error_code=2001)
bind_info = check_member_bind(openid, 1)
if not bind_info:
req = request.json
nickname = req['nickName'] if 'nickName' in req else ''
sex = req['gender'] if 'gender' in req else 0
avatar = req['avatarUrl'] if 'avatarUrl' in req else ''
model_member = Member()
model_member.nickname = nickname
model_member.sex = sex
model_member.avatar = avatar
model_member.salt = MemberService.gene_salt()
model_member.updated_time = model_member.created_time = get_current_date(
)
with db.auto_commit():
db.session.add(model_member)
with db.auto_commit():
model_bind = MemberAuthBind()
model_bind.member_id = model_member.id
model_bind.type = ClientTypeEnum.USER_MINA.value
model_bind.openid = openid
model_bind.extra = ''
model_bind.updated_time = model_bind.created_time = get_current_date(
)
db.session.add(model_bind)
bind_info = model_member
member_info = Member.query.filter_by(id=bind_info.id).first()
return member_info
def get_access_token(self):
token = None
token_info = AuthAccessToken.query.filter(
AuthAccessToken.expired_time >= get_current_date()).first()
if token_info:
token = token_info.access_token
return token
config_mina = current_app.config['MINA_APP']
url = "https://api.weixin.qq.com/cgi-bin/token?grant_type=client_credential&appid={0}&secret={1}"\
.format(config_mina['appid'],config_mina['appkey'])
r = requests.get(url=url)
if r.status_code != 200 or not r.text:
return token
data = json.loads(r.text)
now = datetime.datetime.now()
date = now + datetime.timedelta(seconds=data['expires_in'] - 200)
model_token = AuthAccessToken()
model_token.access_token = data['access_token']
model_token.expired_time = date.strftime("%Y-%m-%d %H:%M:%S")
model_token.created_time = get_current_date()
with db.auto_commit():
db.session.add(model_token)
return data['access_token']
def upload_by_file(file):
config_upload = current_app.config['UPLOAD']
resp = {'code': 200, 'msg': '操作成功', 'data': {}}
file_name = secure_filename(file.filename)
ext = file_name.rsplit('.', 1)[1]
if ext not in config_upload['ext']:
resp['code'] = -1
resp['msg'] = "不允许的扩展类型文件"
return resp
root_path = current_app.root_path + config_upload['prefix_path']
file_dir = get_current_date('%Y%m%d')
save_dir = root_path + file_dir
if not os.path.exists(save_dir):
os.mkdir(save_dir)
os.chmod(save_dir,
stat.S_IRWXU | stat.S_IRGRP | stat.S_IRWXO) # 给文件夹授权
file_name = str(uuid.uuid4()).replace(
'-', '') + '.' + ext # 根据硬件和时间创建一个唯一不重复的字符串
file.save('{0}/{1}'.format(save_dir, file_name))
model_image = Image()
model_image.file_key = file_dir + '/' + file_name
model_image.created_time = get_current_date()
with db.auto_commit():
db.session.add(model_image)
resp['data'] = {'file_key': file_dir + "/" + file_name}
return resp
def stat_site(self, params):
act = params['act']
date = params['date']
date_from = params['date_from']
date_to = params['date_to']
app.logger.info("act:{0},from:{1},to:{2}".format(
act, date_from, date_to))
stat_pay = db.session.query(
func.sum(PayOrder.total_price).label("total_pay_money")) \
.filter(PayOrder.status == 1) \
.filter(PayOrder.created_time >= date_from,
PayOrder.created_time <= date_to).first()
stat_member_count = Member.query.count()
stat_new_member_count = Member.query.filter(
Member.created_time >= date_from,
Member.created_time <= date_to).count()
stat_order_count = PayOrder.query.filter_by(status=1)\
.filter(PayOrder.created_time >= date_from, PayOrder.created_time <= date_to)\
.count()
stat_share_count = WxShareHistory.query.filter(
WxShareHistory.created_time >= date_from,
WxShareHistory.created_time <= date_to).count()
tmp_stat_site = StatDailySite.query.filter_by(date=date).first()
if tmp_stat_site:
tmp_model_stat_site = tmp_stat_site
else:
tmp_model_stat_site = StatDailySite()
tmp_model_stat_site.date = date
tmp_model_stat_site.created_time = get_current_date()
tmp_model_stat_site.total_pay_money = stat_pay[0] if stat_pay[
0] else 0.00
tmp_model_stat_site.total_new_member_count = stat_new_member_count
tmp_model_stat_site.total_member_count = stat_member_count
tmp_model_stat_site.total_order_count = stat_order_count
tmp_model_stat_site.total_shared_count = stat_share_count
tmp_model_stat_site.updated_time = get_current_date()
# 模拟数据
if tmp_model_stat_site.total_pay_money == 0:
tmp_model_stat_site.total_pay_money = random.randint(1000, 1010)
tmp_model_stat_site.total_new_member_count = random.randint(50, 100)
if tmp_model_stat_site.total_new_member_count == 0:
tmp_model_stat_site.total_member_count += \
tmp_model_stat_site.total_new_member_count
if tmp_model_stat_site.total_order_count == 0:
tmp_model_stat_site.total_order_count = random.randint(900, 1000)
if tmp_model_stat_site.total_shared_count == 0:
tmp_model_stat_site.total_shared_count = random.randint(1000, 2000)
with db.auto_commit():
db.session.add(tmp_model_stat_site)
def stat_member(self, params):
act = params['act']
date = params['date']
date_from = params['date_from']
date_to = params['date_to']
app.logger.info("act:{0},from:{1},to:{2}".format(
act, date_from, date_to))
member_list = Member.query.all()
if not member_list:
app.logger.info("no member list")
return
for member_info in member_list:
tmp_stat_member = StatDailyMember.query.filter_by(
date=date, member_id=member_info.id).first()
if tmp_stat_member:
tmp_model_stat_member = tmp_stat_member
else:
tmp_model_stat_member = StatDailyMember()
tmp_model_stat_member.date = date
tmp_model_stat_member.member_id = member_info.id
tmp_model_stat_member.created_time = get_current_date()
tmp_stat_pay = db.session.query(func.sum(
PayOrder.total_price).label("total_pay_money")) \
.filter(PayOrder.member_id == member_info.id, PayOrder.status == 1) \
.filter(PayOrder.created_time >= date_from,
PayOrder.created_time <= date_to).first()
tmp_stat_share_count = WxShareHistory.query.filter(
PayOrder.member_id == member_info.id) \
.filter(PayOrder.created_time >= date_from,
PayOrder.created_time <= date_to).count()
tmp_model_stat_member.total_shared_count = tmp_stat_share_count
tmp_model_stat_member.total_pay_money = tmp_stat_pay[
0] if tmp_stat_pay[0] else 0.00
# 模拟数据
tmp_model_stat_member.total_shared_count = random.randint(50, 100)
if tmp_model_stat_member.total_pay_money == 0:
tmp_model_stat_member.total_pay_money = random.randint(
1000, 1010)
tmp_model_stat_member.updated_time = get_current_date()
with db.auto_commit():
db.session.add(tmp_model_stat_member)
return
def my_comment_add():
member_info = g.user
form = CommentForm().validate_for_api()
order_sn = form.order_sn.data
score = form.score.data
content = form.content.data
pay_order_info = PayOrder.query.filter_by(member_id=member_info.uid,
order_sn=order_sn).first()
if not pay_order_info:
return ParameterException('系统繁忙，请稍后再试')
if pay_order_info.comment_status:
return ParameterException('已经评价过了')
pay_order_items = PayOrderItem.query.filter_by(
pay_order_id=pay_order_info.id).all()
food_ids = select_filter_obj(pay_order_items, "food_id")
tmp_food_ids_str = '_'.join(str(s) for s in food_ids if s not in [None])
model_comment = MemberComments()
model_comment.food_ids = "_%s_" % tmp_food_ids_str
model_comment.member_id = member_info.uid
model_comment.pay_order_id = pay_order_info.id
model_comment.score = score
model_comment.content = content
with db.auto_commit():
db.session.add(model_comment)
pay_order_info.comment_status = 1
pay_order_info.updated_time = get_current_date()
with db.auto_commit():
pay_order_info
return Success()
def ops():
req = request.values
f_id = req['id'] if 'id' in req else 0
act = req['act'] if 'act' in req else ''
if not f_id:
return AjaxFail('请选择要操作的账号')
if act not in ['remove', 'recover']:
return AjaxFail('操作有误，请重试')
food_info = Food.query.filter_by(id=f_id).first()
if not food_info:
return AjaxFail('指定美食不存在')
if act == "remove":
food_info.status = 0
elif act == "recover":
food_info.status = 1
food_info.updated_time = get_current_date()
with db.auto_commit():
food_info
return AjaxSuccess()
def ops():
req = request.values
id = req['id'] if 'id' in req else 0
act = req['act'] if 'act' in req else ''
if not id:
return AjaxFail('请选择要操作的账号')
if act not in ['remove', 'recover']:
return AjaxFail(msg='操作有误，请重试')
user_info = User.query.filter_by(uid=id).first()
if not user_info:
return AjaxFail('指定账号不存在')
if act == "remove":
user_info.status = 0
elif act == "recover":
user_info.status = 1
if user_info and user_info.uid == 1:
return AjaxFail('该用户super账号，不准操作')
user_info.updated_time = get_current_date()
with db.auto_commit():
user_info
if user_info.uid == current_user.uid and user_info.status == 0:
logout_user()
return AjaxSuccess()
def stat_food(self, params):
act = params['act']
date = params['date']
date_from = params['date_from']
date_to = params['date_to']
app.logger.info("act:{0},from:{1},to:{2}".format(
act, date_from, date_to))
stat_food_list = db.session.query(FoodSaleChangeLog.food_id, func.sum(
FoodSaleChangeLog.quantity).label("total_count"),
func.sum(FoodSaleChangeLog.price).label("total_pay_money")) \
.filter(FoodSaleChangeLog.created_time >= date_from,
FoodSaleChangeLog.created_time <= date_to)\
.group_by(FoodSaleChangeLog.food_id).all()
if not stat_food_list:
app.logger.info("no data")
return
for item in stat_food_list:
tmp_food_id = item[0]
tmp_stat_food = StatDailyFood.query.filter_by(
date=date, food_id=tmp_food_id).first()
if tmp_stat_food:
tmp_model_stat_food = tmp_stat_food
else:
tmp_model_stat_food = StatDailyFood()
tmp_model_stat_food.date = date
tmp_model_stat_food.food_id = tmp_food_id
tmp_model_stat_food.created_time = get_current_date()
tmp_model_stat_food.total_count = item[1]
tmp_model_stat_food.total_pay_money = item[2]
tmp_model_stat_food.updated_time = get_current_date()
# 模拟数据
if tmp_model_stat_food.total_count == 0:
tmp_model_stat_food.total_count = random.randint(50, 100)
if tmp_model_stat_food.total_pay_money == 0:
tmp_model_stat_food.total_pay_money = random.randint(
1000, 1010)
with db.auto_commit():
db.session.add(tmp_model_stat_food)
return
def set_items(member_id=0, food_id=0, number=0):
if member_id < 1 or food_id < 1 or number < 1:
return False
cart_info = MemberCart.query.filter_by(food_id=food_id,
member_id=member_id).first()
if cart_info:
model_cart = cart_info
else:
model_cart = MemberCart()
model_cart.member_id = member_id
model_cart.created_time = get_current_date()
model_cart.food_id = food_id
model_cart.quantity = number
model_cart.updated_time = get_current_date()
with db.auto_commit():
db.session.add(model_cart)
return True
def run(self, params):
list = QueueList.query.filter_by(status=-1)\
.order_by(QueueList.id.asc()).limit(1).all()
for item in list:
if item.queue_name == "pay":
self.handle_pay(item)
item.status = 1
item.updated_time = get_current_date()
with db.auto_commit():
item
def add_queue(queue_name, data=None):
model_queue = QueueList()
model_queue.queue_name = queue_name
if data:
model_queue.data = json.dumps(data)
model_queue.created_time = model_queue.updated_time = get_current_date(
)
with db.auto_commit():
db.session.add(model_queue)
return True
def add_error_log(content):
if 'favicon.ico' in request.url:
return
target = AppErrorLog()
target.target_url = request.url
target.referer_url = request.referrer
target.query_params = json.dumps(request.values.to_dict())
target.content = content
target.created_time = get_current_date()
with db.auto_commit():
db.session.add(target)
return True
def order_success(self, pay_order_id=0, params=None):
try:
pay_order_info = PayOrder.query.filter_by(id=pay_order_id).first()
if not pay_order_info or pay_order_info.status not in [-8, -7]:
return True
# 处理订单状态
pay_order_info.pay_sn = params[
'pay_sn'] if params and 'pay_sn' in params else ''
pay_order_info.status = 1
pay_order_info.express_status = -7
pay_order_info.pay_time = get_current_date()
pay_order_info.updated_time = get_current_date()
db.session.add(pay_order_info)
# 售卖历史
pay_order_items = PayOrderItem.query.filter_by(
pay_order_id=pay_order_id).all()
for order_item in pay_order_items:
tmp_model_sale_log = FoodSaleChangeLog()
tmp_model_sale_log.food_id = order_item.food_id
tmp_model_sale_log.quantity = order_item.quantity
tmp_model_sale_log.price = order_item.price
tmp_model_sale_log.member_id = order_item.member_id
tmp_model_sale_log.created_time = get_current_date()
db.session.add(tmp_model_sale_log)
db.session.commit()
except Exception as e:
db.session.rollback()
print(e)
return False
# 加入通知队列，做消息提醒
QueueList.add_queue(
"pay", {
"member_id": pay_order_info.member_id,
"pay_order_id": pay_order_info.id
})
return True
def my_address_ops():
form = OpsForm().validate_for_api()
id = form.id.data
act = form.act.data
member_info = g.user
address_info = MemberAddress.query.filter_by(
id=id, member_id=member_info.uid).first()
if not address_info:
return ParameterException('系统繁忙，请稍后再试')
if act == "del":
address_info.status = 0
address_info.updated_time = get_current_date()
elif act == "default":
MemberAddress.query.filter_by(member_id=member_info.uid)\
.update({'is_default': 0})
address_info.is_default = 1
address_info.updated_time = get_current_date()
with db.auto_commit():
address_info
return Success()
def add_pay_callback_data(self, pay_order_id=0, type='pay', data=''):
model_callback = PayOrderCallbackData()
model_callback.pay_order_id = pay_order_id
if type == "pay":
model_callback.pay_data = data
model_callback.refund_data = ''
else:
model_callback.refund_data = data
model_callback.pay_data = ''
model_callback.created_time = model_callback.updated_time = get_current_date(
)
db.session.add(model_callback)
db.session.commit()
return True
def add_access_log():
target = AppAccessLog()
target.target_url = request.url
target.referer_url = request.referrer
target.ip = request.remote_addr
target.query_params = json.dumps(request.values.to_dict())
# if 'current_user' in g and g.current_user is not None: 拦截器方式
# target.uid = g.current_user.uid
if current_user.is_authenticated:
target.uid = current_user.uid
target.ua = request.headers.get("User-Agent")
target.created_time = get_current_date()
with db.auto_commit():
db.session.add(target)
return True
def order_ops():
req = request.values
id = req['id'] if 'id' in req else 0
act = req['act'] if 'act' in req else ''
pay_order_info = PayOrder.query.filter_by(id=id).first()
if not pay_order_info:
return AjaxFail('系统繁忙。请稍后再试')
if act == "express":
pay_order_info.express_status = -6
pay_order_info.updated_time = get_current_date()
with db.auto_commit():
pay_order_info
return AjaxSuccess()
def set_stock_change_log(food_id=0, quantity=0, note=''):
if food_id < 1:
return False
food_info = Food.query.filter_by(id=food_id).first()
if not food_info:
return False
model_stock_change = FoodStockChangeLog()
model_stock_change.food_id = food_id
model_stock_change.unit = quantity
model_stock_change.total_stock = food_info.stock
model_stock_change.note = note
model_stock_change.created_time = get_current_date()
with db.auto_commit():
db.session.add(model_stock_change)
return True
def member_share():
form = ShareForm().validate_for_api()
# req = request.get_json(silent=True)
# url = req['url'] if 'url' in req else ''
member_info = g.user
model_share = WxShareHistory()
is_exist = model_share.query.filter_by(share_url=form.url.data,
member_id=member_info.uid).first()
if is_exist:
return Success(msg='已经分享过了')
if member_info:
model_share.member_id = member_info.uid
model_share.share_url = form.url.data
model_share.created_time = get_current_date()
with db.auto_commit():
db.session.add(model_share)
return Success(msg='分享成功')
def order_ops():
member_info = g.user
form = OrderOpsForm().validate_for_api()
order_sn = form.order_sn.data
act = form.act.data
pay_order_info = PayOrder.query.filter_by(
order_sn=order_sn, member_id=member_info.uid).first()
if not pay_order_info:
return ParameterException('系统繁忙。请稍后再试')
if act == "cancel":
target_pay = PayService()
ret = target_pay.close_order(pay_order_id=pay_order_info.id)
if not ret:
return ParameterException('系统繁忙。请稍后再试')
elif act == "confirm":
pay_order_info.express_status = 1
pay_order_info.updated_time = get_current_date()
with db.auto_commit():
pay_order_info
return Success('操作成功')
def set():
if request.method == "GET":
resp_data = {}
req = request.args
m_id = int(req.get("id", 0))
back_url = UrlManager.build_url("/member/index")
if m_id < 1:
return redirect(back_url)
member_info = Member.query.filter_by(id=m_id).first()
if not member_info:
return redirect(back_url)
if member_info.status != 1:
return redirect(back_url)
resp_data['info'] = member_info
resp_data['current'] = 'index'
return render_template("member/set.html", **resp_data)
req = request.values
m_id = req['id'] if 'id' in req else 0
nickname = req['nickname'] if 'nickname' in req else ''
if nickname is None or len(nickname) < 1:
return AjaxFail('请输入符合规范的姓名')
member_info = Member.query.filter_by(id=m_id).first()
if not member_info:
return AjaxFail('指定会员不存在')
member_info.nickname = nickname
member_info.updated_time = get_current_date()
with db.auto_commit():
member_info
return AjaxSuccess()
def category_ops():
req = request.values
c_id = req['id'] if 'id' in req else 0
act = req['act'] if 'act' in req else ''
if not c_id:
return AjaxFail('请选择要操作的账号')
if act not in ['remove', 'recover']:
return AjaxFail('操作有误，请重试')
food_category_info = FoodCategory.query.filter_by(id=c_id).first()
if not food_category_info:
return AjaxFail('指定分类不存在')
if act == "remove":
food_category_info.status = 0
elif act == "recover":
food_category_info.status = 1
food_category_info.update_time = get_current_date()
with db.auto_commit():
db.session.add(food_category_info)
return AjaxSuccess()
def set():
default_pwd = "******"
if request.method == "GET":
resp_data = {}
req = request.args
uid = int(req.get("id", 0))
info = None
if uid:
info = User.query.filter_by(uid=uid).first()
resp_data['info'] = info
return render_template("account/set.html", **resp_data)
req = request.values
id = req['id'] if 'id' in req else 0
nickname = req['nickname'] if 'nickname' in req else ''
mobile = req['mobile'] if 'mobile' in req else ''
email = req['email'] if 'email' in req else ''
login_name = req['login_name'] if 'login_name' in req else ''
login_pwd = req['login_pwd'] if 'login_pwd' in req else ''
if nickname is None or len(nickname) < 1:
return AjaxFail('请输入符合规范的姓名')
if mobile is None or len(mobile) < 1:
return AjaxFail('请输入符合规范的手机号码')
if email is None or len(email) < 1:
return AjaxFail('请输入符合规范的邮箱')
if login_name is None or len(login_name) < 1:
return AjaxFail('请输入符合规范的登录用户名')
if login_pwd is None or len(email) < 6:
return AjaxFail('请输入符合规范的登录密码')
has_in = User.query.filter(User.login_name == login_name,
User.uid != id).first()
if has_in:
return AjaxFail('该登录名已存在，请换一个试试')
user_info = User.query.filter_by(uid=id).first()
if user_info:
model_user = user_info
else:
model_user = User()
model_user.created_time = get_current_date()
model_user.login_salt = UserService.gene_salt()
model_user.nickname = nickname
model_user.mobile = mobile
model_user.email = email
model_user.login_name = login_name
if login_pwd != default_pwd:
# if user_info and user_info.uid == 1:
# resp['code'] = -1
# resp['msg'] = "该用户是演示账号，不准修改密码和登录用户名"
# return jsonify(resp)
model_user.login_pwd = UserService.gene_pwd(login_pwd,
model_user.login_salt)
model_user.updated_time = get_current_date()
with db.auto_commit():
db.session.add(model_user)
return AjaxSuccess()
def set():
if request.method == 'GET':
resp_data = {}
req = request.args
id = int(req.get('id', 0))
info = Food.query.filter_by(id=id).first()
if info and info.status != 1:
return redirect(UrlManager.build_url('/food/index'))
c_list = FoodCategory.query.all()
resp_data['info'] = info
resp_data['c_list'] = c_list
resp_data['current'] = 'index'
return render_template("food/set.html", **resp_data)
req = request.values
id = int(req['id']) if 'id' in req and req['id'] else 0
cat_id = int(req['cat_id']) if 'cat_id' in req else 0
name = req['name'] if 'name' in req else ''
price = req['price'] if 'price' in req else ''
main_image = req['main_image'] if 'main_image' in req else ''
summary = req['summary'] if 'summary' in req else ''
stock = int(req['stock']) if 'stock' in req else ''
tags = req['tags'] if 'tags' in req else ''
if cat_id < 1:
return AjaxFail('请选择分类')
if name is None or len(name) < 1:
return AjaxFail('请输入符合规范的名称')
if not price or len(price) < 1:
return AjaxFail('请输入符合规范的售卖价格')
price = Decimal(price).quantize(Decimal('0.00'))
if price <= 0:
return AjaxFail('请输入符合规范的售卖价格')
if main_image is None or len(main_image) < 3:
return AjaxFail('请上传封面图')
if summary is None or len(summary) < 3:
return AjaxFail('请输入图书描述，并不能少于10个字符')
if stock < 1:
return AjaxFail('请输入符合规范的库存量')
if tags is None or len(tags) < 1:
return AjaxFail('请输入标签，便于搜索')
food_info = Food.query.filter_by(id=id).first()
before_stock = 0
if food_info:
model_food = food_info
before_stock = model_food.stock
else:
model_food = Food()
model_food.status = 1
model_food.created_time = get_current_date()
model_food.cat_id = cat_id
model_food.name = name
model_food.price = price
model_food.main_image = main_image
model_food.summary = summary
model_food.stock = stock
model_food.tags = tags
model_food.updated_time = get_current_date()
with db.auto_commit():
db.session.add(model_food)
PayService.set_stock_change_log(model_food.id,
int(stock) - int(before_stock), "后台修改")
return AjaxSuccess()
def create_order(self, member_id, items=None, params=None):
pay_price = decimal.Decimal(0.00)
continue_cnt = 0
food_ids = []
for item in items:
if decimal.Decimal(item['price']) < 0:
continue_cnt += 1
continue
pay_price = pay_price + decimal.Decimal(item['price']) * int(
item['number'])
food_ids.append(item['id'])
if continue_cnt >= len(items):
return ParameterException('商品items为空')
yun_price = params[
'yun_price'] if params and 'yun_price' in params else 0
note = params['note'] if params and 'note' in params else ''
yun_price = decimal.Decimal(yun_price)
total_price = pay_price + yun_price
express_address_id = params[
'express_address_id'] if params and 'express_address_id' in params else 0
express_info = params[
'express_info'] if params and 'express_info' in params else {}
# SELECT * FROM food where id=5 for update 可以控制并发，
# 执行for update时，在没执行commit()前，不能执行其他for update
with db.auto_commit():
tmp_food_list = db.session.query(Food).filter(Food.id.in_(food_ids))\
.with_for_update().all()
tmp_food_stock_mapping = {}
for tmp_item in tmp_food_list:
tmp_food_stock_mapping[tmp_item.id] = tmp_item.stock
model_pay_order = PayOrder()
model_pay_order.order_sn = self.gene_order_sn()
model_pay_order.member_id = member_id
model_pay_order.total_price = total_price
model_pay_order.yun_price = yun_price
model_pay_order.pay_price = pay_price
model_pay_order.note = note
model_pay_order.status = -8
model_pay_order.express_status = -8
model_pay_order.express_address_id = express_address_id
model_pay_order.express_info = json.dumps(express_info)
model_pay_order.updated_time = \
model_pay_order.created_time = get_current_date()
db.session.add(model_pay_order)
for item in items:
tmp_left_stock = tmp_food_stock_mapping[item['id']]
if decimal.Decimal(item['price']) < 0:
continue
if int(item['number']) > int(tmp_left_stock):
raise ParameterException('您购买的这商品太火爆了，剩余：%s,您购买%s~~' %
(tmp_left_stock, item['number']))
tmp_ret = Food.query.filter_by(id=item['id']).update(
{"stock": int(tmp_left_stock) - int(item['number'])})
if not tmp_ret:
raise ParameterException('下单失败请重新下单')
tmp_pay_item = PayOrderItem()
tmp_pay_item.pay_order_id = model_pay_order.id
tmp_pay_item.member_id = member_id
tmp_pay_item.quantity = item['number']
tmp_pay_item.price = item['price']
tmp_pay_item.food_id = item['id']
tmp_pay_item.note = note
tmp_pay_item.updated_time = tmp_pay_item.created_time = get_current_date(
)
db.session.add(tmp_pay_item)
self.set_stock_change_log(item['id'], -item['number'], "在线购买")
# time.sleep(10) 测试for update时用
resp = {}
resp['data'] = {
'id': model_pay_order.id,
'order_sn': model_pay_order.order_sn,
'total_price': str(total_price)
}
return resp
