Não pode escolher mais do que 25 tópicos
Os tópicos devem começar com uma letra ou um número, podem incluir traços ('-') e podem ter até 35 caracteres.
402 linhas
18 KiB
402 linhas
18 KiB
import sqlite3 as sqlite
|
|
from sqlalchemy.exc import SQLAlchemyError
|
|
from sqlalchemy import and_
|
|
from be.model import postgreSQLORM
|
|
from be.model.postgreSQLORM import Store_Book
|
|
from be.model.postgreSQLORM import New_Order_Detail
|
|
from be.model.postgreSQLORM import New_Order
|
|
from be.model.postgreSQLORM import User
|
|
import uuid
|
|
|
|
import json
|
|
import logging
|
|
import time
|
|
from be.model import db_conn
|
|
from be.model import error
|
|
|
|
|
|
from datetime import datetime
|
|
import threading
|
|
from datetime import timedelta
|
|
|
|
to_be_overtime={}
|
|
def overtime_append(key,value):#对to_be_overtime进行操作
|
|
global to_be_overtime
|
|
if key in to_be_overtime:
|
|
to_be_overtime[key].append(value)
|
|
else:
|
|
to_be_overtime[key]=[value]
|
|
|
|
class TimerClass(threading.Thread):
|
|
def __init__(self):
|
|
threading.Thread.__init__(self)
|
|
self.event = threading.Event()
|
|
|
|
def thread(self):
|
|
# threading.Thread(target=Buyer().auto_cancel(to_be_overtime[(datetime.utcnow() + timedelta(seconds=1)).second])).start()
|
|
# 上面这个，有利有弊利是超过一秒也能处理 弊是每有任何一次路由访问就要延时开一次线程次数秒
|
|
Buyer().auto_cancel(to_be_overtime[(datetime.utcnow() + timedelta(seconds=1)).second])
|
|
|
|
def run(self): # 每秒运行一次 将超时订单删去
|
|
global to_be_overtime
|
|
# schedule.every().second.do(thread)#每秒开一个线程去auto_cancel,做完的线程自动退出
|
|
while not self.event.is_set():
|
|
self.event.wait(1)
|
|
if (datetime.utcnow() + timedelta(seconds=1)).second in to_be_overtime:
|
|
self.thread()
|
|
# schedule.run_pending()
|
|
|
|
def cancel_timer(self):
|
|
self.event.set()
|
|
|
|
# tmr = TimerClass()#####################在无需测试自动取消订单test时删去 单独测取消订单请在test.sh中用
|
|
# #coverage run --timid --branch --source fe,be --concurrency=thread -m pytest -v -k fe/test/test_new_order.py --ignore=fe/data
|
|
# tmr.start()###################在无需测试自动取消订单test时删去
|
|
|
|
def tostop():
|
|
global tmr
|
|
tmr.cancel_timer()
|
|
|
|
|
|
def jwt_encode(user_id: str, terminal: str) -> str:
|
|
encoded = jwt.encode(
|
|
{"user_id": user_id, "terminal": terminal, "timestamp": time.time()},
|
|
key=user_id,
|
|
algorithm="HS256",
|
|
)
|
|
return encoded.decode("utf-8")
|
|
|
|
# decode a JWT to a json string like:
|
|
# {
|
|
# "user_id": [user name],
|
|
# "terminal": [terminal code],
|
|
# "timestamp": [ts]} to a JWT
|
|
# }
|
|
def jwt_decode(encoded_token, user_id: str) -> str:
|
|
decoded = jwt.decode(encoded_token, key=user_id, algorithms="HS256")
|
|
return decoded
|
|
|
|
class DateEncoder(json.JSONEncoder):
|
|
def default(self, obj):
|
|
if isinstance(obj, datetime):
|
|
return obj.strftime("%Y-%m-%d %H:%M:%S")
|
|
else:
|
|
return json.JSONEncoder.default(self, obj)
|
|
|
|
|
|
class Buyer(db_conn.DBConn):
|
|
def __init__(self):
|
|
db_conn.DBConn.__init__(self)
|
|
|
|
def new_order(self, user_id: str, store_id: str, id_and_count: [(str, int)]) -> (int, str, str):
|
|
order_id = ""
|
|
try:
|
|
if not self.user_id_exist(user_id):
|
|
return error.error_non_exist_user_id(user_id) + (order_id, )
|
|
if not self.store_id_exist(store_id):
|
|
return error.error_non_exist_store_id(store_id) + (order_id, )
|
|
uid = "{}_{}_{}".format(user_id, store_id, str(uuid.uuid1()))
|
|
# print("touch0")
|
|
for book_id, count in id_and_count:
|
|
row = self.session.query(postgreSQLORM.Store_Book).filter(and_(postgreSQLORM.Store_Book.store_id==store_id,postgreSQLORM.Store_Book.book_id==book_id)).first()
|
|
# cursor = self.conn.execute(
|
|
# "SELECT book_id, stock_level, book_info FROM store "
|
|
# "WHERE store_id = ? AND book_id = ?;",
|
|
# (store_id, book_id))
|
|
# row = cursor.fetchone()
|
|
if row is None:
|
|
return error.error_non_exist_book_id(book_id) + (order_id, )
|
|
|
|
# stock_level = row[1]
|
|
# book_info = row[2]
|
|
stock_level = row.stock_level
|
|
book_info = row.book_info
|
|
|
|
book_info_json = json.loads(book_info)
|
|
price = book_info_json.get("price")
|
|
|
|
if stock_level < count:
|
|
return error.error_stock_level_low(book_id) + (order_id,)
|
|
# print("touch2")
|
|
row = self.session.query(Store_Book).filter(and_(Store_Book.store_id==store_id,Store_Book.book_id==book_id,Store_Book.stock_level>=count)).update({'stock_level':Store_Book.stock_level-count})
|
|
# cursor = self.conn.execute(
|
|
# "UPDATE store set stock_level = stock_level - ? "
|
|
# "WHERE store_id = ? and book_id = ? and stock_level >= ?; ",
|
|
# (count, store_id, book_id, count))
|
|
|
|
# if cursor.rowcount == 0:
|
|
# print("touch3")
|
|
if row == 0:
|
|
return error.error_stock_level_low(book_id) + (order_id, )
|
|
|
|
# print("touch4")
|
|
|
|
new_order_detail_entity = New_Order_Detail(order_id=uid,book_id=book_id,count=count,price=price)
|
|
# print("touch5")
|
|
row = self.session.add(new_order_detail_entity)
|
|
# self.session.commit()
|
|
# self.conn.execute(
|
|
# "INSERT INTO new_order_detail(order_id, book_id, count, price) "
|
|
# "VALUES(?, ?, ?, ?);",
|
|
# (uid, book_id, count, price))
|
|
# print("touch1")
|
|
timenow = datetime.utcnow()
|
|
creat_time = time.strftime("%Y-%m-%d %H:%M:%S",time.localtime()) ## 订单创建时间
|
|
new_order_entity = New_Order(order_id=uid,store_id=store_id,user_id=user_id,creat_time=creat_time,status=0)
|
|
self.session.add(new_order_entity)
|
|
# self.conn.execute(
|
|
# "INSERT INTO new_order(order_id, store_id, user_id) "
|
|
# "VALUES(?, ?, ?);",
|
|
# (uid, store_id, user_id))
|
|
# self.conn.commit()
|
|
overtime_append(timenow.second,order_id) ##将刚下单的订单加入到overtime中管理
|
|
self.session.commit()
|
|
order_id = uid
|
|
|
|
except SQLAlchemyError as e:
|
|
logging.info("528, {}".format(str(e)))
|
|
return 528, "{}".format(str(e)), ""
|
|
except BaseException as e:
|
|
logging.info("530, {}".format(str(e)))
|
|
return 530, "{}".format(str(e)), ""
|
|
|
|
return 200, "ok", order_id
|
|
|
|
def payment(self, user_id: str, password: str, order_id: str) -> (int, str):
|
|
# conn = self.conn
|
|
session = self.session
|
|
try:
|
|
row = session.query(New_Order).filter(New_Order.order_id==order_id).first()
|
|
# cursor = conn.execute("SELECT order_id, user_id, store_id FROM new_order WHERE order_id = ?", (order_id,))
|
|
# row = cursor.fetchone()
|
|
if row is None:
|
|
return error.error_invalid_order_id(order_id)
|
|
|
|
# order_id = row[0]
|
|
# buyer_id = row[1]
|
|
# store_id = row[2]
|
|
order_id = row.order_id
|
|
buyer_id = row.user_id
|
|
store_id = row.store_id
|
|
|
|
if buyer_id != user_id:
|
|
return error.error_authorization_fail()
|
|
|
|
row = session.query(postgreSQLORM.User).filter(postgreSQLORM.User.user_id==buyer_id).first()
|
|
# cursor = conn.execute("SELECT balance, password FROM user WHERE user_id = ?;", (buyer_id,))
|
|
# row = cursor.fetchone()
|
|
if row is None:
|
|
return error.error_non_exist_user_id(buyer_id)
|
|
# balance = row[0]
|
|
balance = row.balance
|
|
pwd = row.password
|
|
if password != pwd:
|
|
return error.error_authorization_fail()
|
|
|
|
row = session.query(postgreSQLORM.User_Store).filter(postgreSQLORM.User_Store.store_id==store_id).first()
|
|
# cursor = conn.execute("SELECT store_id, user_id FROM user_store WHERE store_id = ?;", (store_id,))
|
|
# row = cursor.fetchone()
|
|
if row is None:
|
|
return error.error_non_exist_store_id(store_id)
|
|
|
|
# seller_id = row[1]
|
|
seller_id = row.user_id
|
|
|
|
if not self.user_id_exist(seller_id):
|
|
return error.error_non_exist_user_id(seller_id)
|
|
|
|
row = session.query(New_Order_Detail).filter(New_Order_Detail.order_id==order_id).all()
|
|
# cursor = conn.execute("SELECT book_id, count, price FROM new_order_detail WHERE order_id = ?;", (order_id,))
|
|
total_price = 0
|
|
# for row in cursor:
|
|
# count = row[1]
|
|
# price = row[2]
|
|
# total_price = total_price + price * count
|
|
for i in row:
|
|
count = i.count
|
|
price = i.price
|
|
total_price = total_price + price * count
|
|
|
|
if balance < total_price:
|
|
return error.error_not_sufficient_funds(order_id)
|
|
|
|
# print('touch0')
|
|
## 买家扣钱
|
|
row = session.query(User).filter(and_(User.balance>=total_price,User.user_id==buyer_id)).update({'balance':User.balance-total_price})
|
|
# cursor = conn.execute("UPDATE user set balance = balance - ?"
|
|
# "WHERE user_id = ? AND balance >= ?",
|
|
# (total_price, buyer_id, total_price))
|
|
# if cursor.rowcount == 0:
|
|
if row == 0:
|
|
return error.error_not_sufficient_funds(order_id)
|
|
# print('touch1')
|
|
## 卖家加钱
|
|
row = session.query(User).filter(User.user_id==seller_id).update({'balance':User.balance+total_price})
|
|
# cursor = conn.execute("UPDATE user set balance = balance + ?"
|
|
# "WHERE user_id = ?",
|
|
# (total_price, buyer_id))
|
|
# if cursor.rowcount == 0:
|
|
if row == 0:
|
|
return error.error_non_exist_user_id(buyer_id)
|
|
# print('touch2')
|
|
# row = session.query(New_Order).filter(New_Order.order_id==order_id).delete() 不在删除而是修改订单状态
|
|
row = session.query(New_Order).filter(New_Order.order_id==order_id).update({'status':1})
|
|
# cursor = conn.execute("DELETE FROM new_order WHERE order_id = ?", (order_id, ))
|
|
# if cursor.rowcount == 0:
|
|
if row == 0:
|
|
return error.error_invalid_order_id(order_id)
|
|
|
|
# row = session.query(New_Order_Detail).filter(New_Order_Detail.order_id==order_id).delete()
|
|
# cursor = conn.execute("DELETE FROM new_order_detail where order_id = ?", (order_id, ))
|
|
# if cursor.rowcount == 0:
|
|
if row == 0:
|
|
return error.error_invalid_order_id(order_id)
|
|
|
|
# conn.commit()
|
|
session.commit()
|
|
|
|
except SQLAlchemyError as e:
|
|
return 528, "{}".format(str(e))
|
|
|
|
except BaseException as e:
|
|
return 530, "{}".format(str(e))
|
|
|
|
return 200, "ok"
|
|
|
|
def add_funds(self, user_id, password, add_value) -> (int, str):
|
|
try:
|
|
row = self.session.query(postgreSQLORM.User).filter(postgreSQLORM.User.user_id==user_id).first()
|
|
# cursor = self.conn.execute("SELECT password from user where user_id=?", (user_id,))
|
|
# row = cursor.fetchone()
|
|
if row is None:
|
|
return error.error_authorization_fail()
|
|
|
|
pwd = row.password
|
|
if pwd != password:
|
|
return error.error_authorization_fail()
|
|
|
|
row = self.session.query(postgreSQLORM.User).filter_by(user_id=user_id).update({'balance':postgreSQLORM.User.balance+add_value,'user_id':user_id})
|
|
# cursor = self.conn.execute(
|
|
# "UPDATE user SET balance = balance + ? WHERE user_id = ?",
|
|
# (add_value, user_id))
|
|
if row == 0:
|
|
return error.error_non_exist_user_id(user_id)
|
|
|
|
self.session.commit()
|
|
# self.conn.commit()
|
|
except SQLAlchemyError as e:
|
|
return 528, "{}".format(str(e))
|
|
except BaseException as e:
|
|
return 530, "{}".format(str(e))
|
|
|
|
return 200, "ok"
|
|
|
|
def take_over(self, user_id, order_id):
|
|
session = self.session
|
|
try:
|
|
if not self.user_id_exist(user_id):
|
|
return error.error_non_exist_user_id(user_id)
|
|
|
|
row = session.query(New_Order).filter(and_(New_Order.order_id==order_id,New_Order.user_id==user_id)).first()
|
|
if row is None:
|
|
return error.error_invalid_order_id(order_id)
|
|
if row.status != 2:
|
|
return error.error_invalid_order_id(order_id)
|
|
|
|
row = session.query(New_Order).filter(and_(New_Order.order_id==order_id,New_Order.user_id==user_id)).update({'status':3})
|
|
|
|
if row == 0:
|
|
return error.error_invalid_order_id(order_id)
|
|
|
|
session.commit()
|
|
|
|
except SQLAlchemyError as e:
|
|
return 528, "{}".format(str(e))
|
|
except BaseException as e:
|
|
# print('touch3')
|
|
return 530, "{}".format(str(e))
|
|
return 200, "ok"
|
|
|
|
def order_cancel(self, user_id, order_id):
|
|
session = self.session
|
|
try:
|
|
if not self.user_id_exist(user_id):
|
|
return error.error_non_exist_user_id(user_id)
|
|
|
|
row = session.query(New_Order).filter(and_(New_Order.order_id==order_id,New_Order.user_id==user_id)).first()
|
|
if row is None:
|
|
return error.error_invalid_order_id(order_id)
|
|
if row.status != 0:
|
|
return error.error_invalid_order_id(order_id)
|
|
store_id = row.store_id
|
|
row2 = session.query(New_Order_Detail).filter(New_Order_Detail.order_id==order_id).first()
|
|
book_id = row2.book_id
|
|
count = row2.count
|
|
row3 = session.query(Store_Book).filter(and_(Store_Book.store_id==store_id,Store_Book.book_id==book_id)).update({'stock_level':Store_Book.stock_level+count})
|
|
row = session.query(New_Order).filter(and_(New_Order.order_id==order_id,New_Order.user_id==user_id)).update({'status':-1})
|
|
|
|
if row == 0:
|
|
return error.error_invalid_order_id(order_id)
|
|
|
|
session.commit()
|
|
|
|
except SQLAlchemyError as e:
|
|
return 528, "{}".format(str(e))
|
|
except BaseException as e:
|
|
# print('touch3')
|
|
return 530, "{}".format(str(e))
|
|
return 200, "ok"
|
|
|
|
def history_order(self, user_id):
|
|
session = self.session
|
|
try:
|
|
if not self.user_id_exist(user_id):
|
|
return error.error_non_exist_user_id(user_id)
|
|
row = session.query(New_Order).filter(New_Order.user_id==user_id).first()
|
|
if row is None:
|
|
return error.error_non_exist_user_id(user_id)
|
|
row = session.query(New_Order).filter(New_Order.user_id==user_id).order_by(New_Order.creat_time.desc()).all()
|
|
order_ids = []
|
|
for i in row:
|
|
order_ids.append(i.order_id)
|
|
session.commit()
|
|
except SQLAlchemyError as e:
|
|
return 528, "{}".format(str(e))
|
|
except BaseException as e:
|
|
# print('touch3')
|
|
return 530, "{}".format(str(e))
|
|
return 200, "ok", order_ids
|
|
|
|
def auto_cancel(self,order_id_list):#自动取消订单
|
|
exist_order_need_cancel=0
|
|
|
|
try:
|
|
for order_id in order_id_list:
|
|
row = self.session.query(New_Order).filter(New_Order.order_id==order_id).first()
|
|
|
|
if row is None:
|
|
return error.error_invalid_order_id(order_id)
|
|
#是否属于未付款订单
|
|
if row.status == 0:
|
|
timenow = datetime.utcnow()
|
|
check_time = time.strftime("%Y-%m-%d %H:%M:%S",time.localtime())
|
|
creat_time = row.creat_time
|
|
time_1_struct = datetime.strptime(creat_time, "%Y-%m-%d %H:%M:%S")
|
|
time_2_struct = datetime.strptime(check_time, "%Y-%m-%d %H:%M:%S")
|
|
seconds = (time_2_struct - time_1_struct).seconds
|
|
if seconds>= 30: ## 订单超过30秒为付款自动取消
|
|
store_id = row.store_id
|
|
row3 = self.session.query(New_Order).filter(New_Order_Detail.order_id==order_id).first()
|
|
book_id = row3.book_id
|
|
count = row3.count
|
|
self.session.query(Store_Book).filter(and_(Store_Book.store_id==store_id,Store_Book.book_id==book_id)).update({'stock_level':Store_Book.stock_level+count})
|
|
self.session.query(New_Order).filter(New_Order.order_id==order_id).update({'status':-1})
|
|
exist_order_need_cancel = 1
|
|
self.session.commit()
|
|
except SQLAlchemyError as e:
|
|
return 528, "{}".format(str(e))
|
|
except BaseException as e:
|
|
# print('touch3')
|
|
return 530, "{}".format(str(e))
|
|
return 'no_such_order' if exist_order_need_cancel==0 else "auto_cancel_done"
|
|
|