major refactoring adding vendor and customer features
This commit is contained in:
@@ -1,16 +1,24 @@
|
||||
# tests/unit/models/test_database_models.py
|
||||
import pytest
|
||||
from datetime import datetime, timezone
|
||||
from sqlalchemy.exc import IntegrityError
|
||||
|
||||
from models.database.marketplace_product import MarketplaceProduct
|
||||
from models.database.vendor import Vendor
|
||||
from models.database.stock import Stock
|
||||
from models.database.vendor import Vendor, VendorUser, Role
|
||||
from models.database.inventory import Inventory
|
||||
from models.database.user import User
|
||||
from models.database.marketplace_import_job import MarketplaceImportJob
|
||||
from models.database.product import Product
|
||||
from models.database.customer import Customer, CustomerAddress
|
||||
from models.database.order import Order, OrderItem
|
||||
|
||||
|
||||
@pytest.mark.unit
|
||||
@pytest.mark.database
|
||||
class TestDatabaseModels:
|
||||
def test_user_model(self, db):
|
||||
class TestUserModel:
|
||||
"""Test User model"""
|
||||
|
||||
def test_user_creation(self, db):
|
||||
"""Test User model creation and relationships"""
|
||||
user = User(
|
||||
email="db_test@example.com",
|
||||
@@ -26,52 +34,49 @@ class TestDatabaseModels:
|
||||
|
||||
assert user.id is not None
|
||||
assert user.email == "db_test@example.com"
|
||||
assert user.username == "dbtest"
|
||||
assert user.role == "user"
|
||||
assert user.is_active is True
|
||||
assert user.created_at is not None
|
||||
assert user.updated_at is not None
|
||||
|
||||
def test_product_model(self, db):
|
||||
"""Test MarketplaceProduct model creation"""
|
||||
marketplace_product = MarketplaceProduct(
|
||||
marketplace_product_id="DB_TEST_001",
|
||||
title="Database Test MarketplaceProduct",
|
||||
description="Testing product model",
|
||||
price="25.99",
|
||||
currency="USD",
|
||||
brand="DBTest",
|
||||
gtin="1234567890123",
|
||||
availability="in stock",
|
||||
marketplace="TestDB",
|
||||
vendor_name="DBTestVendor",
|
||||
def test_user_email_uniqueness(self, db):
|
||||
"""Test email unique constraint"""
|
||||
user1 = User(
|
||||
email="unique@example.com",
|
||||
username="user1",
|
||||
hashed_password="hash1",
|
||||
)
|
||||
|
||||
db.add(marketplace_product)
|
||||
db.add(user1)
|
||||
db.commit()
|
||||
db.refresh(marketplace_product)
|
||||
|
||||
assert marketplace_product.id is not None
|
||||
assert marketplace_product.marketplace_product_id == "DB_TEST_001"
|
||||
assert marketplace_product.created_at is not None
|
||||
# Duplicate email should raise error
|
||||
with pytest.raises(IntegrityError):
|
||||
user2 = User(
|
||||
email="unique@example.com",
|
||||
username="user2",
|
||||
hashed_password="hash2",
|
||||
)
|
||||
db.add(user2)
|
||||
db.commit()
|
||||
|
||||
def test_stock_model(self, db):
|
||||
"""Test Stock model creation"""
|
||||
stock = Stock(gtin="1234567890123", location="DB_WAREHOUSE", quantity=150)
|
||||
|
||||
db.add(stock)
|
||||
db.commit()
|
||||
db.refresh(stock)
|
||||
@pytest.mark.unit
|
||||
@pytest.mark.database
|
||||
class TestVendorModel:
|
||||
"""Test Vendor model"""
|
||||
|
||||
assert stock.id is not None
|
||||
assert stock.gtin == "1234567890123"
|
||||
assert stock.location == "DB_WAREHOUSE"
|
||||
assert stock.quantity == 150
|
||||
|
||||
def test_vendor_model_with_owner(self, db, test_user):
|
||||
def test_vendor_creation_with_owner(self, db, test_user):
|
||||
"""Test Vendor model with owner relationship"""
|
||||
vendor = Vendor(
|
||||
vendor_code="DBTEST",
|
||||
vendor_name="Database Test Vendor",
|
||||
subdomain="dbtest",
|
||||
name="Database Test Vendor",
|
||||
description="Testing vendor model",
|
||||
owner_id=test_user.id,
|
||||
owner_user_id=test_user.id,
|
||||
contact_email="contact@dbtest.com",
|
||||
contact_phone="+1234567890",
|
||||
business_address="123 Test Street",
|
||||
is_active=True,
|
||||
is_verified=False,
|
||||
)
|
||||
@@ -82,18 +87,508 @@ class TestDatabaseModels:
|
||||
|
||||
assert vendor.id is not None
|
||||
assert vendor.vendor_code == "DBTEST"
|
||||
assert vendor.owner_id == test_user.id
|
||||
assert vendor.subdomain == "dbtest"
|
||||
assert vendor.name == "Database Test Vendor"
|
||||
assert vendor.owner_user_id == test_user.id
|
||||
assert vendor.owner.username == test_user.username
|
||||
assert vendor.contact_email == "contact@dbtest.com"
|
||||
assert vendor.is_active is True
|
||||
assert vendor.is_verified is False
|
||||
|
||||
def test_database_constraints(self, db):
|
||||
"""Test database constraints and unique indexes"""
|
||||
# Test unique marketplace_product_id constraint
|
||||
product1 = MarketplaceProduct(marketplace_product_id="UNIQUE_001", title="MarketplaceProduct 1")
|
||||
def test_vendor_with_letzshop_urls(self, db, test_user):
|
||||
"""Test Vendor model with multi-language Letzshop URLs"""
|
||||
vendor = Vendor(
|
||||
vendor_code="MULTILANG",
|
||||
subdomain="multilang",
|
||||
name="Multi-Language Vendor",
|
||||
owner_user_id=test_user.id,
|
||||
letzshop_csv_url_fr="https://example.com/feed_fr.csv",
|
||||
letzshop_csv_url_en="https://example.com/feed_en.csv",
|
||||
letzshop_csv_url_de="https://example.com/feed_de.csv",
|
||||
is_active=True,
|
||||
)
|
||||
|
||||
db.add(vendor)
|
||||
db.commit()
|
||||
db.refresh(vendor)
|
||||
|
||||
assert vendor.letzshop_csv_url_fr == "https://example.com/feed_fr.csv"
|
||||
assert vendor.letzshop_csv_url_en == "https://example.com/feed_en.csv"
|
||||
assert vendor.letzshop_csv_url_de == "https://example.com/feed_de.csv"
|
||||
|
||||
def test_vendor_code_uniqueness(self, db, test_user):
|
||||
"""Test vendor_code unique constraint"""
|
||||
vendor1 = Vendor(
|
||||
vendor_code="UNIQUE",
|
||||
subdomain="unique1",
|
||||
name="Unique Vendor 1",
|
||||
owner_user_id=test_user.id,
|
||||
)
|
||||
db.add(vendor1)
|
||||
db.commit()
|
||||
|
||||
# Duplicate vendor_code should raise error
|
||||
with pytest.raises(IntegrityError):
|
||||
vendor2 = Vendor(
|
||||
vendor_code="UNIQUE",
|
||||
subdomain="unique2",
|
||||
name="Unique Vendor 2",
|
||||
owner_user_id=test_user.id,
|
||||
)
|
||||
db.add(vendor2)
|
||||
db.commit()
|
||||
|
||||
def test_subdomain_uniqueness(self, db, test_user):
|
||||
"""Test subdomain unique constraint"""
|
||||
vendor1 = Vendor(
|
||||
vendor_code="VENDOR1",
|
||||
subdomain="testsubdomain",
|
||||
name="Vendor 1",
|
||||
owner_user_id=test_user.id,
|
||||
)
|
||||
db.add(vendor1)
|
||||
db.commit()
|
||||
|
||||
# Duplicate subdomain should raise error
|
||||
with pytest.raises(IntegrityError):
|
||||
vendor2 = Vendor(
|
||||
vendor_code="VENDOR2",
|
||||
subdomain="testsubdomain",
|
||||
name="Vendor 2",
|
||||
owner_user_id=test_user.id,
|
||||
)
|
||||
db.add(vendor2)
|
||||
db.commit()
|
||||
|
||||
|
||||
@pytest.mark.unit
|
||||
@pytest.mark.database
|
||||
class TestTeamModels:
|
||||
"""Test VendorUser and Role models"""
|
||||
|
||||
def test_role_creation(self, db, test_vendor):
|
||||
"""Test Role model creation"""
|
||||
role = Role(
|
||||
vendor_id=test_vendor.id,
|
||||
name="Manager",
|
||||
permissions=["products.create", "orders.view"],
|
||||
)
|
||||
db.add(role)
|
||||
db.commit()
|
||||
db.refresh(role)
|
||||
|
||||
assert role.id is not None
|
||||
assert role.vendor_id == test_vendor.id
|
||||
assert role.name == "Manager"
|
||||
assert "products.create" in role.permissions
|
||||
assert "orders.view" in role.permissions
|
||||
|
||||
def test_vendor_user_creation(self, db, test_vendor, test_user):
|
||||
"""Test VendorUser model for team management"""
|
||||
# Create a role
|
||||
role = Role(
|
||||
vendor_id=test_vendor.id,
|
||||
name="Manager",
|
||||
permissions=["products.create", "orders.view"],
|
||||
)
|
||||
db.add(role)
|
||||
db.commit()
|
||||
|
||||
# Create vendor user
|
||||
vendor_user = VendorUser(
|
||||
vendor_id=test_vendor.id,
|
||||
user_id=test_user.id,
|
||||
role_id=role.id,
|
||||
is_active=True,
|
||||
)
|
||||
db.add(vendor_user)
|
||||
db.commit()
|
||||
db.refresh(vendor_user)
|
||||
|
||||
assert vendor_user.id is not None
|
||||
assert vendor_user.vendor_id == test_vendor.id
|
||||
assert vendor_user.user_id == test_user.id
|
||||
assert vendor_user.role.name == "Manager"
|
||||
assert "products.create" in vendor_user.role.permissions
|
||||
|
||||
def test_vendor_user_uniqueness(self, db, test_vendor, test_user):
|
||||
"""Test vendor_user unique constraint (one user per vendor)"""
|
||||
role = Role(
|
||||
vendor_id=test_vendor.id,
|
||||
name="Editor",
|
||||
permissions=["products.view"],
|
||||
)
|
||||
db.add(role)
|
||||
db.commit()
|
||||
|
||||
vendor_user1 = VendorUser(
|
||||
vendor_id=test_vendor.id,
|
||||
user_id=test_user.id,
|
||||
role_id=role.id,
|
||||
)
|
||||
db.add(vendor_user1)
|
||||
db.commit()
|
||||
|
||||
# Same user can't be added to same vendor twice
|
||||
with pytest.raises(IntegrityError):
|
||||
vendor_user2 = VendorUser(
|
||||
vendor_id=test_vendor.id,
|
||||
user_id=test_user.id,
|
||||
role_id=role.id,
|
||||
)
|
||||
db.add(vendor_user2)
|
||||
db.commit()
|
||||
|
||||
|
||||
@pytest.mark.unit
|
||||
@pytest.mark.database
|
||||
class TestMarketplaceProductModel:
|
||||
"""Test MarketplaceProduct model"""
|
||||
|
||||
def test_marketplace_product_creation(self, db, test_vendor):
|
||||
"""Test MarketplaceProduct model creation with vendor_id"""
|
||||
marketplace_product = MarketplaceProduct(
|
||||
vendor_id=test_vendor.id,
|
||||
marketplace_product_id="DB_TEST_001",
|
||||
title="Database Test Product",
|
||||
description="Testing product model",
|
||||
price="25.99",
|
||||
currency="USD",
|
||||
brand="DBTest",
|
||||
gtin="1234567890123",
|
||||
availability="in stock",
|
||||
marketplace="Letzshop",
|
||||
)
|
||||
|
||||
db.add(marketplace_product)
|
||||
db.commit()
|
||||
db.refresh(marketplace_product)
|
||||
|
||||
assert marketplace_product.id is not None
|
||||
assert marketplace_product.vendor_id == test_vendor.id
|
||||
assert marketplace_product.marketplace_product_id == "DB_TEST_001"
|
||||
assert marketplace_product.title == "Database Test Product"
|
||||
assert marketplace_product.marketplace == "Letzshop"
|
||||
assert marketplace_product.created_at is not None
|
||||
|
||||
def test_marketplace_product_id_uniqueness(self, db, test_vendor):
|
||||
"""Test unique marketplace_product_id constraint"""
|
||||
product1 = MarketplaceProduct(
|
||||
vendor_id=test_vendor.id,
|
||||
marketplace_product_id="UNIQUE_001",
|
||||
title="Product 1",
|
||||
marketplace="Letzshop"
|
||||
)
|
||||
db.add(product1)
|
||||
db.commit()
|
||||
|
||||
# This should raise an integrity error
|
||||
with pytest.raises(Exception): # Could be IntegrityError or similar
|
||||
product2 = MarketplaceProduct(marketplace_product_id="UNIQUE_001", title="MarketplaceProduct 2")
|
||||
# Duplicate marketplace_product_id should raise error
|
||||
with pytest.raises(IntegrityError):
|
||||
product2 = MarketplaceProduct(
|
||||
vendor_id=test_vendor.id,
|
||||
marketplace_product_id="UNIQUE_001",
|
||||
title="Product 2",
|
||||
marketplace="Letzshop"
|
||||
)
|
||||
db.add(product2)
|
||||
db.commit()
|
||||
|
||||
|
||||
@pytest.mark.unit
|
||||
@pytest.mark.database
|
||||
class TestProductModel:
|
||||
"""Test Product (vendor catalog) model"""
|
||||
|
||||
def test_product_creation(self, db, test_vendor, test_marketplace_product):
|
||||
"""Test Product model linking vendor catalog to marketplace product"""
|
||||
product = Product(
|
||||
vendor_id=test_vendor.id,
|
||||
marketplace_product_id=test_marketplace_product.id,
|
||||
product_id="VENDOR_PROD_001",
|
||||
price=89.99, # Vendor override price
|
||||
currency="EUR",
|
||||
availability="in stock",
|
||||
is_featured=True,
|
||||
is_active=True,
|
||||
)
|
||||
|
||||
db.add(product)
|
||||
db.commit()
|
||||
db.refresh(product)
|
||||
|
||||
assert product.id is not None
|
||||
assert product.vendor_id == test_vendor.id
|
||||
assert product.marketplace_product_id == test_marketplace_product.id
|
||||
assert product.price == 89.99
|
||||
assert product.is_featured is True
|
||||
assert product.vendor.vendor_code == test_vendor.vendor_code
|
||||
assert product.marketplace_product.title == test_marketplace_product.title
|
||||
|
||||
def test_product_unique_per_vendor(self, db, test_vendor, test_marketplace_product):
|
||||
"""Test that same marketplace product can't be added twice to vendor catalog"""
|
||||
product1 = Product(
|
||||
vendor_id=test_vendor.id,
|
||||
marketplace_product_id=test_marketplace_product.id,
|
||||
is_active=True,
|
||||
)
|
||||
db.add(product1)
|
||||
db.commit()
|
||||
|
||||
# Same marketplace product to same vendor should fail
|
||||
with pytest.raises(IntegrityError):
|
||||
product2 = Product(
|
||||
vendor_id=test_vendor.id,
|
||||
marketplace_product_id=test_marketplace_product.id,
|
||||
is_active=True,
|
||||
)
|
||||
db.add(product2)
|
||||
db.commit()
|
||||
|
||||
|
||||
@pytest.mark.unit
|
||||
@pytest.mark.database
|
||||
class TestInventoryModel:
|
||||
"""Test Inventory model"""
|
||||
|
||||
def test_inventory_creation_with_product(self, db, test_vendor, test_product):
|
||||
"""Test Inventory model linked to product"""
|
||||
inventory = Inventory(
|
||||
product_id=test_product.id,
|
||||
vendor_id=test_vendor.id,
|
||||
location="WAREHOUSE_A",
|
||||
quantity=150,
|
||||
reserved_quantity=10,
|
||||
gtin=test_product.marketplace_product.gtin,
|
||||
)
|
||||
|
||||
db.add(inventory)
|
||||
db.commit()
|
||||
db.refresh(inventory)
|
||||
|
||||
assert inventory.id is not None
|
||||
assert inventory.product_id == test_product.id
|
||||
assert inventory.vendor_id == test_vendor.id
|
||||
assert inventory.location == "WAREHOUSE_A"
|
||||
assert inventory.quantity == 150
|
||||
assert inventory.reserved_quantity == 10
|
||||
assert inventory.available_quantity == 140 # 150 - 10
|
||||
|
||||
def test_inventory_unique_product_location(self, db, test_vendor, test_product):
|
||||
"""Test unique constraint on product_id + location"""
|
||||
inventory1 = Inventory(
|
||||
product_id=test_product.id,
|
||||
vendor_id=test_vendor.id,
|
||||
location="WAREHOUSE_A",
|
||||
quantity=100,
|
||||
)
|
||||
db.add(inventory1)
|
||||
db.commit()
|
||||
|
||||
# Same product + location should fail
|
||||
with pytest.raises(IntegrityError):
|
||||
inventory2 = Inventory(
|
||||
product_id=test_product.id,
|
||||
vendor_id=test_vendor.id,
|
||||
location="WAREHOUSE_A",
|
||||
quantity=50,
|
||||
)
|
||||
db.add(inventory2)
|
||||
db.commit()
|
||||
|
||||
|
||||
@pytest.mark.unit
|
||||
@pytest.mark.database
|
||||
class TestMarketplaceImportJobModel:
|
||||
"""Test MarketplaceImportJob model"""
|
||||
|
||||
def test_import_job_creation(self, db, test_user, test_vendor):
|
||||
"""Test MarketplaceImportJob model with relationships"""
|
||||
import_job = MarketplaceImportJob(
|
||||
vendor_id=test_vendor.id,
|
||||
user_id=test_user.id,
|
||||
marketplace="Letzshop",
|
||||
source_url="https://example.com/feed.csv",
|
||||
status="pending",
|
||||
imported_count=0,
|
||||
updated_count=0,
|
||||
error_count=0,
|
||||
total_processed=0,
|
||||
)
|
||||
|
||||
db.add(import_job)
|
||||
db.commit()
|
||||
db.refresh(import_job)
|
||||
|
||||
assert import_job.id is not None
|
||||
assert import_job.vendor_id == test_vendor.id
|
||||
assert import_job.user_id == test_user.id
|
||||
assert import_job.marketplace == "Letzshop"
|
||||
assert import_job.source_url == "https://example.com/feed.csv"
|
||||
assert import_job.status == "pending"
|
||||
assert import_job.vendor.vendor_code == test_vendor.vendor_code
|
||||
assert import_job.user.username == test_user.username
|
||||
|
||||
|
||||
@pytest.mark.unit
|
||||
@pytest.mark.database
|
||||
class TestCustomerModel:
|
||||
"""Test Customer model"""
|
||||
|
||||
def test_customer_creation(self, db, test_vendor):
|
||||
"""Test Customer model with vendor isolation"""
|
||||
customer = Customer(
|
||||
vendor_id=test_vendor.id,
|
||||
email="customer@example.com",
|
||||
hashed_password="hashed_password",
|
||||
first_name="John",
|
||||
last_name="Doe",
|
||||
customer_number="CUST001",
|
||||
is_active=True,
|
||||
)
|
||||
|
||||
db.add(customer)
|
||||
db.commit()
|
||||
db.refresh(customer)
|
||||
|
||||
assert customer.id is not None
|
||||
assert customer.vendor_id == test_vendor.id
|
||||
assert customer.email == "customer@example.com"
|
||||
assert customer.customer_number == "CUST001"
|
||||
assert customer.first_name == "John"
|
||||
assert customer.last_name == "Doe"
|
||||
assert customer.vendor.vendor_code == test_vendor.vendor_code
|
||||
|
||||
def test_customer_email_unique_per_vendor(self, db, test_vendor):
|
||||
"""Test email is unique within vendor scope only"""
|
||||
customer1 = Customer(
|
||||
vendor_id=test_vendor.id,
|
||||
email="same@example.com",
|
||||
hashed_password="hash1",
|
||||
first_name="Customer",
|
||||
last_name="One",
|
||||
customer_number="CUST001",
|
||||
)
|
||||
db.add(customer1)
|
||||
db.commit()
|
||||
|
||||
# Same email in same vendor should fail
|
||||
with pytest.raises(IntegrityError):
|
||||
customer2 = Customer(
|
||||
vendor_id=test_vendor.id,
|
||||
email="same@example.com",
|
||||
hashed_password="hash2",
|
||||
first_name="Customer",
|
||||
last_name="Two",
|
||||
customer_number="CUST002",
|
||||
)
|
||||
db.add(customer2)
|
||||
db.commit()
|
||||
|
||||
def test_customer_address_creation(self, db, test_vendor, test_customer):
|
||||
"""Test CustomerAddress model"""
|
||||
address = CustomerAddress(
|
||||
vendor_id=test_vendor.id,
|
||||
customer_id=test_customer.id,
|
||||
address_type="shipping",
|
||||
first_name="John",
|
||||
last_name="Doe",
|
||||
address_line_1="123 Main St",
|
||||
city="Luxembourg",
|
||||
postal_code="L-1234",
|
||||
country="Luxembourg",
|
||||
is_default=True,
|
||||
)
|
||||
|
||||
db.add(address)
|
||||
db.commit()
|
||||
db.refresh(address)
|
||||
|
||||
assert address.id is not None
|
||||
assert address.vendor_id == test_vendor.id
|
||||
assert address.customer_id == test_customer.id
|
||||
assert address.address_type == "shipping"
|
||||
assert address.is_default is True
|
||||
|
||||
|
||||
@pytest.mark.unit
|
||||
@pytest.mark.database
|
||||
class TestOrderModel:
|
||||
"""Test Order model"""
|
||||
|
||||
def test_order_creation(self, db, test_vendor, test_customer, test_customer_address):
|
||||
"""Test Order model with customer relationship"""
|
||||
order = Order(
|
||||
vendor_id=test_vendor.id,
|
||||
customer_id=test_customer.id,
|
||||
order_number="ORD-001",
|
||||
status="pending",
|
||||
subtotal=99.99,
|
||||
total_amount=99.99,
|
||||
currency="EUR",
|
||||
shipping_address_id=test_customer_address.id,
|
||||
billing_address_id=test_customer_address.id,
|
||||
)
|
||||
|
||||
db.add(order)
|
||||
db.commit()
|
||||
db.refresh(order)
|
||||
|
||||
assert order.id is not None
|
||||
assert order.vendor_id == test_vendor.id
|
||||
assert order.customer_id == test_customer.id
|
||||
assert order.order_number == "ORD-001"
|
||||
assert order.status == "pending"
|
||||
assert float(order.total_amount) == 99.99
|
||||
|
||||
def test_order_item_creation(self, db, test_order, test_product):
|
||||
"""Test OrderItem model"""
|
||||
order_item = OrderItem(
|
||||
order_id=test_order.id,
|
||||
product_id=test_product.id,
|
||||
product_name=test_product.marketplace_product.title,
|
||||
product_sku=test_product.product_id,
|
||||
quantity=2,
|
||||
unit_price=49.99,
|
||||
total_price=99.98,
|
||||
)
|
||||
|
||||
db.add(order_item)
|
||||
db.commit()
|
||||
db.refresh(order_item)
|
||||
|
||||
assert order_item.id is not None
|
||||
assert order_item.order_id == test_order.id
|
||||
assert order_item.product_id == test_product.id
|
||||
assert order_item.quantity == 2
|
||||
assert float(order_item.unit_price) == 49.99
|
||||
assert float(order_item.total_price) == 99.98
|
||||
|
||||
def test_order_number_uniqueness(self, db, test_vendor, test_customer, test_customer_address):
|
||||
"""Test order_number unique constraint"""
|
||||
order1 = Order(
|
||||
vendor_id=test_vendor.id,
|
||||
customer_id=test_customer.id,
|
||||
order_number="UNIQUE-ORD-001",
|
||||
status="pending",
|
||||
subtotal=50.00,
|
||||
total_amount=50.00,
|
||||
shipping_address_id=test_customer_address.id,
|
||||
billing_address_id=test_customer_address.id,
|
||||
)
|
||||
db.add(order1)
|
||||
db.commit()
|
||||
|
||||
# Duplicate order number should fail
|
||||
with pytest.raises(IntegrityError):
|
||||
order2 = Order(
|
||||
vendor_id=test_vendor.id,
|
||||
customer_id=test_customer.id,
|
||||
order_number="UNIQUE-ORD-001",
|
||||
status="pending",
|
||||
subtotal=75.00,
|
||||
total_amount=75.00,
|
||||
shipping_address_id=test_customer_address.id,
|
||||
billing_address_id=test_customer_address.id,
|
||||
)
|
||||
db.add(order2)
|
||||
db.commit()
|
||||
|
||||
Reference in New Issue
Block a user