修复bug, 实现订单分页搜索功能

payment_backend/app.py

@@ -47,7 +47,7 @@ def create_order():
 
     wallet_address = data.get('wallet_address', None)
     if wallet_address is None:
-        wallet_addresses = user_service.get_wallet_addresses(name, phone, email)
+        wallet_addresses = user_service.get_wallet_addresses(name, phone, email, payment_method)
 
         if not wallet_addresses:
             return jsonify({
@@ -60,9 +60,12 @@ def create_order():
             }), 200
         # 单个地址
         wallet_address = wallet_addresses[0]
+    else:
+        user_service.update_or_create(name, phone, email, wallet_address, payment_method)
 
     order_id, create_timestamp = order_service.create_order(name=name, phone=phone, email=email,
-                                                            quant=quant, wallet_address=wallet_address)
+                                                            quant=quant, payment_method=payment_method,
+                                                            wallet_address=wallet_address)
 
     return jsonify({"orderID": order_id,
                     "amount": quant,
@@ -83,8 +86,7 @@ def query_order():
     offset = (page - 1) * page_size
     limit = page_size
 
-
+    orders = order_service.query_order(name, phone, email, wallet_address, offset, limit)
-    orders = order_service.queryOrder(name, phone, email, wallet_address, offset, limit)
     return jsonify({"orders": orders}), 200
 
 

payment_backend/models.py

@@ -12,19 +12,22 @@ class User:
 
     def insert_sql(self, params_format="list"):
         params_sql, params = pack_params(params_format=params_format, param_sql="{param}", join_str=",",
-                                         name=self.name, phone=self.phone, email=self.email, wallet_address=self.wallet_address,
+                                         name=self.name, phone=self.phone, email=self.email,
+                                         wallet_address=self.wallet_address,
                                          payment_method=self.payment_method)
         return f"INSERT INTO users ({params_sql}) VALUES ({','.join('%s' for _ in params)})", params
 
     def select_sql(self, condition="AND", params_format="list"):
         params_sql, params = pack_params(params_format=params_format, param_sql="{param}=%s", join_str=f" {condition} ",
-                                         name=self.name, phone=self.phone, email=self.email, wallet_address=self.wallet_address,
+                                         name=self.name, phone=self.phone, email=self.email,
+                                         wallet_address=self.wallet_address,
                                          payment_method=self.payment_method)
         return f"SELECT id, name, phone, email, wallet_address, payment_method FROM users WHERE {params_sql}", params
 
     def exists_sql(self, condition="AND", params_format="list"):
         params_sql, params = pack_params(params_format=params_format, param_sql="{param}=%s", join_str=f" {condition} ",
-                                         name=self.name, phone=self.phone, email=self.email, wallet_address=self.wallet_address,
+                                         name=self.name, phone=self.phone, email=self.email,
+                                         wallet_address=self.wallet_address,
                                          payment_method=self.payment_method)
         return f"SELECT id FROM users WHERE {params_sql} LIMIT 1", params
 
@@ -85,15 +88,17 @@ class User:
     def __hash__(self):
         return hash((self.name, self.phone, self.email, self.wallet_address, self.payment_method))
 
+
 class Order:
-    def __init__(self, id_=None, order_id=None, name=None, phone=None, email=None, quant=None, from_address=None,
+    def __init__(self, id_=None, order_id=None, name=None, phone=None, email=None, quant=None, payment_method=None,
-                 to_address=None, create_timestamp=None, update_timestamp=None, status=None):
+                 from_address=None, to_address=None, create_timestamp=None, update_timestamp=None, status=None):
         self.id = id_
         self.order_id = order_id
         self.name = name
         self.phone = phone
         self.email = email
         self.quant = quant
+        self.payment_method = payment_method
         self.from_address = from_address
         self.to_address = to_address
         self.create_timestamp = create_timestamp
@@ -103,24 +108,28 @@ class Order:
     def insert_sql(self, params_format="list"):
         params_sql, params = pack_params(params_format=params_format, param_sql="{param}", join_str=",",
                                          order_id=self.order_id, name=self.name, phone=self.phone, email=self.email,
-                                         quant=self.quant,
+                                         quant=self.quant, payment_method=self.payment_method,
                                          from_address=self.from_address, to_address=self.to_address,
                                          create_timestamp=self.create_timestamp, update_timestamp=self.update_timestamp,
                                          status=self.status)
         return f"INSERT INTO orders ({params_sql}) VALUES ({','.join('%s' for _ in params)})", params
 
-    def select_sql(self, condition="AND", params_format="list"):
+    def select_sql(self, query_columns=None, condition="AND", params_format="list"):
+        if query_columns is None:
+            query_columns = ['order_id', 'name', 'phone', 'email', 'quant', 'payment_method', 'from_address']
         params_sql, params = pack_params(params_format=params_format, param_sql="{param}=%s", join_str=f" {condition} ",
-                                         order_id=self.order_id, name=self.name, phone=self.phone, email=self.email, quant=self.quant,
+                                         order_id=self.order_id, name=self.name, phone=self.phone, email=self.email,
+                                         quant=self.quant, payment_method=self.payment_method,
                                          from_address=self.from_address, to_address=self.to_address,
                                          create_timestamp=self.create_timestamp, update_timestamp=self.update_timestamp,
                                          status=self.status)
-        return f"SELECT id, name, phone, email, wallet_address, payment_method FROM orders WHERE {params_sql}", params
+        return f'SELECT {",".join(query_columns)} FROM orders WHERE {params_sql}', params
 
     def exists_sql(self, condition="AND", params_format="list"):
         params_sql, params = pack_params(params_format=params_format, param_sql="{param}=%s", join_str=f" {condition} ",
-                                         order_id=self.order_id, name=self.name, phone=self.phone, email=self.email, quant=self.quant,
+                                         order_id=self.order_id, name=self.name, phone=self.phone, email=self.email,
+                                         quant=self.quant, payment_method=self.payment_method,
                                          from_address=self.from_address, to_address=self.to_address,
                                          create_timestamp=self.create_timestamp, update_timestamp=self.update_timestamp,
                                          status=self.status)
-        return f"SELECT id FROM orders WHERE {params_sql} LIMIT 1", params
+        return f"SELECT id FROM orders WHERE {params_sql} LIMIT 1", params

payment_backend/repositories/order.py

@@ -48,7 +48,10 @@ class OrderRepository:
         return result
 
     def query(self, order, offset, limit):
-        select_sql, params = order.select_sql()
+        select_sql, params = order.select_sql(
+            query_columns=['order_id', 'name', 'phone', 'email', 'quant', 'payment_method', 'from_address',
+                           'create_timestamp', 'update_timestamp', 'status']
+        )
         select_sql = f"{select_sql} LIMIT %s OFFSET %s"
         params = params + [limit, offset]
         cursor = self.db.execute_query(select_sql, params)

payment_backend/repositories/user.py

@@ -10,7 +10,7 @@ class UserRepository:
     def __init__(self, config):
         self.db = Database(config['MYSQL'])
 
-    def get_or_create(self, user):
+    def get_and_update(self, user):
         users = []
         cursor = self.db.execute_query(*user.select_sql(condition="OR"))
         same_users = cursor.fetchall()
@@ -72,3 +72,9 @@ class UserRepository:
                 raise
             users.append(user)
         return users
+
+    def exist(self, user):
+        cursor = self.db.execute_query(*user.exists_sql())
+        exist = cursor.fetchone()
+        cursor.close()
+        return bool(exist)

payment_backend/services/order.py

@@ -4,27 +4,57 @@ from custom_decorators import singleton
 from models import Order
 from repositories.order import OrderRepository
 from services.payment import PaymentService
-from utils.datetime import current, current_timestamp, is_time_difference_greater_than
+from utils.datetime import current, current_timestamp, is_time_difference_greater_than, timestamp2datetime
 
 
 @singleton
 class OrderService:
     def __init__(self, config):
         self.config = config
+        self.order_status = self.config.order.order_status
         self.payment_service = PaymentService(config.APIKey.tronscan)
         self.order_repo = OrderRepository(config)
 
-    def queryOrder(self, name, phone, email, wallet_address, offset, limit):
+    def query_order(self, name=None, phone=None, email=None, wallet_address=None,
+                    offset=0, limit=10):
         orders = self.order_repo.query(Order(name=name, phone=phone, email=email, from_address=wallet_address),
                                        offset, limit)
-        return orders
+        cleaned_orders = []
+        for order in orders:
+            cleaned_order = []
+            for i, v in enumerate(order):
+                if i == 4: # 交易数量
+                    if v is None:
+                        v = 0
+                    else:
+                        v = int(v)
+                elif i == 7 or i == 8: # 时间戳
+                    if v is None:
+                        v = ''
+                    else:
+                        v = timestamp2datetime(v).strftime("%m/%d/%Y %I:%M:%S %p")
+                elif i == 9: # 订单状态
+                    if v is None or v > len(self.order_status):
+                        v = 0
+                    v = self.order_status[v]
+                else:
+                    if v is None:
+                        v = ''
+                cleaned_order.append(v)
+            cleaned_orders.append(cleaned_order)
+        return cleaned_orders
 
-    def create_order(self, name, phone, email, quant, wallet_address):
+    def create_order(self, name, phone, email, quant, payment_method, wallet_address):
         date_str = current().strftime('%Y%m%d%H%M%S')
         unique_id = str(uuid.uuid4()).split('-')[0]
         order_id = f"{date_str}-{unique_id}"
-        order = Order(order_id=order_id, name=name, phone=phone, email=email, quant=quant,
+        try:
-                      from_address=wallet_address, to_address=self.config['PaymentAddresses']['usdt'])
+            to_address = self.config['PaymentAddresses'][payment_method]
+        except KeyError:
+            raise ValueError("Payment method not supported")
+        order = Order(order_id=order_id, name=name, phone=phone, email=email,
+                      quant=quant, payment_method=payment_method,
+                      from_address=wallet_address, to_address=to_address)
         create_timestamp = self.order_repo.create(order)
         return order_id, create_timestamp
 

payment_backend/services/user.py

@@ -9,9 +9,15 @@ class UserService:
         self.config = config
         self.user_repo = UserRepository(config)
 
-    def get_wallet_addresses(self, name=None, phone=None, email=None):
+    def get_wallet_addresses(self, name=None, phone=None, email=None, payment_method=None):
         if phone or email:
-            users = self.user_repo.get_or_create(User(name=name, phone=phone, email=email))
+            users = self.user_repo.get_and_update(User(name=name, phone=phone, email=email,
+                                                       payment_method=payment_method))
             addresses = set(user.address for user in users if user.address)
             return list(addresses)
         return []
+
+    def update_or_create(self, name=None, phone=None, email=None, wallet_address=None, payment_method=None):
+        self.user_repo.get_and_update(User(name=name, phone=phone, email=email, wallet_address=wallet_address,
+                                           payment_method=payment_method))
+

payment_backend/utils/datetime.py

@@ -10,6 +10,10 @@ def current_timestamp():
     return int(datetime.datetime.now().timestamp() * 1000)
 
 
+def timestamp2datetime(timestamp):
+    return datetime.datetime.fromtimestamp(timestamp / 1000.0)
+
+
 def is_time_difference_greater_than(timestamp1, timestamp2, hours=0, minutes=0, seconds=0, milliseconds=0):
     """
     判断两个时间戳的时间差是否大于指定的小时、分钟和秒数
@@ -25,8 +29,8 @@ def is_time_difference_greater_than(timestamp1, timestamp2, hours=0, minutes=0,
         bool: 如果时间差大于指定的小时、分钟和秒数返回True，否则返回False
     """
     # 将时间戳转换为 datetime 对象
-    time1 = datetime.datetime.fromtimestamp(timestamp1 / 1000.0)
+    time1 = timestamp2datetime(timestamp1)
-    time2 = datetime.datetime.fromtimestamp(timestamp2 / 1000.0)
+    time2 = timestamp2datetime(timestamp2)
 
     # 计算时间差
     time_difference = abs(time2 - time1)
@@ -63,5 +67,6 @@ def parse_time_string(time_str):
 
     return result
 
+
 def to_milliseconds(days=0, hours=0, minutes=0, seconds=0, milliseconds=0):
     return days * 24 * 60 * 60 * 1000 + hours * 60 * 60 * 1000 + minutes * 60 * 1000 + seconds * 1000 + milliseconds