zuowei/erpnew
1
0
Fork 0
forked from erp-dev/erp
Code Pull Requests Activity

feat: app verion && some field modify (printing & shipment)

Browse Source
This commit is contained in:
colaftc
2026-07-08 20:36:51 +08:00
parent ddbf798665
commit 36e4bb6de6
32 changed files with 3465 additions and 26 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
api_v1/views/shipment/__init__.py
View File

@@ -6,11 +6,14 @@ Shipment API 模块
from .views import (
SalesItemDetailView,
SalesItemRebuildView,
SalesItemByCustomerGroupView,
SalesItemByCustomerView,
SalesItemByPrintingOrderGroupView,
SalesItemByPrintingOrderView,
SalesItemCreateView,
ShipmentStatusUpdateView,
ShipmentDeliveryBindShipmentsView,
ShipmentDeliveryByPrintingOrderView,
ShipmentDeliveryDetailView,
ShipmentDeliveryListCreateView,
ShipmentDeliveryCancelView,
@@ -24,11 +27,14 @@ from .views import (
__all__ = [
'SalesItemDetailView',
'SalesItemRebuildView',
'SalesItemByCustomerGroupView',
'SalesItemByCustomerView',
'SalesItemByPrintingOrderGroupView',
'SalesItemByPrintingOrderView',
'SalesItemCreateView',
'ShipmentStatusUpdateView',
'ShipmentDeliveryBindShipmentsView',
'ShipmentDeliveryByPrintingOrderView',
'ShipmentDeliveryDetailView',
'ShipmentDeliveryListCreateView',
'ShipmentDeliveryCancelView',

132
api_v1/views/shipment/serializers.py
View File

@@ -111,6 +111,9 @@ class ShipmentSerializer(serializers.ModelSerializer):
"""
customer_name = serializers.CharField(source="customer.name", read_only=True)
address_id = serializers.IntegerField(
source="customer_address.id", read_only=True, allow_null=True
)
created_by_id = serializers.IntegerField(
source="created_by.id", read_only=True, allow_null=True
)
@@ -142,6 +145,7 @@ class ShipmentSerializer(serializers.ModelSerializer):
"merchant_name",
"customer",
"customer_name",
"address_id",
"fabric",
"order_description",
"shipment_date",
@@ -149,11 +153,13 @@ class ShipmentSerializer(serializers.ModelSerializer):
"contact_name",
"contact_phone",
"area",
"coordinates",
"remark",
"status",
"status_display",
"external_id",
"geo_coordinates",
"extra",
"delivery_id",
"status_modified_at",
"cancelled_by_id",
@@ -277,6 +283,12 @@ class ShipmentCreateNormalSerializer(serializers.Serializer):
allow_blank=True,
help_text="地址（可选）",
)
address_id = serializers.IntegerField(
required=False,
allow_null=True,
min_value=1,
help_text="客户地址ID（可选）",
)
contact_name = serializers.CharField(
max_length=100,
required=False,
@@ -292,15 +304,35 @@ class ShipmentCreateNormalSerializer(serializers.Serializer):
help_text="联系电话（可选）",
)
area = serializers.CharField(
max_length=30,
max_length=100,
required=False,
default="",
allow_blank=True,
help_text="出货地区（可选）",
)
coordinates = serializers.CharField(
max_length=100,
required=False,
allow_blank=True,
allow_null=True,
default=None,
help_text="经纬度字符串（可选）",
)
extra = serializers.JSONField(
required=False,
allow_null=True,
default=None,
help_text="扩展信息（可选）",
)
remark = serializers.CharField(
required=False, default="", allow_blank=True, help_text="备注"
)
status = serializers.ChoiceField(
choices=ShipmentStatus.choices,
required=False,
default=ShipmentStatus.DRAFT,
help_text="出货单状态（可选，默认 1=草稿）",
)
sales_items = serializers.ListField(
child=serializers.IntegerField(),
required=False,
@@ -357,12 +389,26 @@ class ShipmentCreateExternalSerializer(serializers.Serializer):
help_text="联系电话（可选）",
)
area = serializers.CharField(
max_length=30,
max_length=100,
required=False,
default="",
allow_blank=True,
help_text="出货地区（可选）",
)
coordinates = serializers.CharField(
max_length=100,
required=False,
allow_blank=True,
allow_null=True,
default=None,
help_text="经纬度字符串（可选）",
)
extra = serializers.JSONField(
required=False,
allow_null=True,
default=None,
help_text="扩展信息（可选）",
)
remark = serializers.CharField(
required=False, default="", allow_blank=True, help_text="备注"
)
@@ -404,7 +450,19 @@ class ShipmentUpdateSerializer(serializers.Serializer):
max_length=50, required=False, allow_blank=True, help_text="联系电话（可选）"
)
area = serializers.CharField(
max_length=30, required=False, allow_blank=True, help_text="出货地区（可选）"
max_length=100, required=False, allow_blank=True, help_text="出货地区（可选）"
)
coordinates = serializers.CharField(
max_length=100,
required=False,
allow_blank=True,
allow_null=True,
help_text="经纬度字符串（可选）",
)
extra = serializers.JSONField(
required=False,
allow_null=True,
help_text="扩展信息（可选）",
)
remark = serializers.CharField(
required=False, allow_blank=True, help_text="备注（可选）"
@@ -650,6 +708,74 @@ class ShipmentDeliverySerializer(serializers.ModelSerializer):
).data
class ShipmentDeliveryByPrintingOrderSerializer(serializers.ModelSerializer):
"""
按生产订单查询送货单的专用 DTO。
当前字段基本对齐送货单列表，后续可按该查询场景独立调整。
"""
status_display = serializers.CharField(source="get_status_display", read_only=True)
merchant_id = serializers.IntegerField(source="merchant.id", read_only=True)
merchant_name = serializers.CharField(source="merchant.name", read_only=True)
created_by_id = serializers.IntegerField(
source="created_by.id", read_only=True, allow_null=True
)
created_by_name = serializers.SerializerMethodField()
operator_id = serializers.IntegerField(
source="operator.id", read_only=True, allow_null=True
)
operator_name = serializers.CharField(source="operator.name", read_only=True, allow_null=True)
shipments_count = serializers.SerializerMethodField()
shipments = serializers.SerializerMethodField()
class Meta:
model = ShipmentDelivery
fields = [
"id",
"merchant_id",
"merchant_name",
"driver_name",
"vehicle_trip",
"contact_phone",
"vehicle_capacity",
"remark",
"internal_remark",
"shipment_order_ids",
"status",
"status_display",
"started_at",
"delivered_at",
"cancelled_at",
"shipments_count",
"shipments",
"created_by_id",
"created_by_name",
"operator_id",
"operator_name",
"created_at",
"updated_at",
]
read_only_fields = fields
def get_created_by_name(self, obj):
if obj.created_by:
employee = getattr(obj.created_by, "employee", None)
if employee:
return employee.name
return obj.created_by.username
return None
def get_shipments_count(self, obj):
return obj.shipments.count()
def get_shipments(self, obj):
return ShipmentDeliveryShipmentSummarySerializer(
obj.shipments.order_by("id"),
many=True,
).data
class ShipmentDeliveryCreateSerializer(serializers.Serializer):
driver_name = serializers.CharField(max_length=100, help_text="司机名")
vehicle_trip = serializers.CharField(max_length=100, help_text="车次")

636
api_v1/views/shipment/test_api.py
View File

@@ -295,6 +295,81 @@ class SalesItemByPrintingOrderAPITestCase(TestCase):
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
self.assertIn("匹配到多个生产订单", response.json()["detail"])
def test_get_sales_items_by_printing_order_group_groups_by_printing_job(self):
url = (
f"/api/v1/shipment/sales-items/by-printing-order/{self.printing_order.id}/"
"group/"
)
response = self.client.get(url)
self.assertEqual(response.status_code, status.HTTP_200_OK)
data = response.json()
self.assertEqual(data["count"], 1)
self.assertEqual(len(data["results"]), 1)
group = data["results"][0]
self.assertEqual(group["printing_job_id"], self.printing_job1.id)
self.assertEqual(group["count"], 2)
self.assertEqual(
{item["id"] for item in group["items"]},
{self.sales_item1.id, self.sales_item2.id},
)
def test_get_sales_items_by_printing_order_group_supports_external_order_id(self):
response = self.client.get(
"/api/v1/shipment/sales-items/by-printing-order/EXT-PO-001/group/"
)
self.assertEqual(response.status_code, status.HTTP_200_OK)
data = response.json()
self.assertEqual(data["count"], 1)
self.assertEqual(data["results"][0]["printing_job_id"], self.printing_job1.id)
def test_get_sales_items_by_printing_order_group_paginates_printing_job_groups(self):
url = (
f"/api/v1/shipment/sales-items/by-printing-order/{self.printing_order.id}/"
"group/?include_already_has_shipment=true&limit=1&offset=1"
)
response = self.client.get(url)
self.assertEqual(response.status_code, status.HTTP_200_OK)
data = response.json()
self.assertEqual(data["count"], 2)
self.assertEqual(len(data["results"]), 1)
self.assertEqual(data["results"][0]["printing_job_id"], self.printing_job2.id)
self.assertEqual(data["results"][0]["count"], 1)
self.assertEqual(data["results"][0]["items"][0]["id"], self.sales_item3.id)
def test_get_sales_items_by_printing_order_group_multiple_external_matches(self):
printing_models.PrintingOrder.objects.create(
merchant=self.merchant,
customer=self.customer,
fabric="测试面料3",
width="160cm",
process=self.process,
created_by=self.user,
external_order_id="EXT-DUPLICATED-GROUP",
)
printing_models.PrintingOrder.objects.create(
merchant=self.merchant,
customer=self.customer,
fabric="测试面料4",
width="170cm",
process=self.process,
created_by=self.user,
external_order_id="EXT-DUPLICATED-GROUP",
)
response = self.client.get(
"/api/v1/shipment/sales-items/by-printing-order/EXT-DUPLICATED-GROUP/group/"
)
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
self.assertIn("匹配到多个生产订单", response.json()["detail"])
def test_get_sales_items_printing_order_not_found(self):
"""测试生产订单不存在"""
url = "/api/v1/shipment/sales-items/by-printing-order/99999/"
@@ -351,6 +426,252 @@ class SalesItemByPrintingOrderAPITestCase(TestCase):
self.assertEqual(response.status_code, status.HTTP_401_UNAUTHORIZED)
class ShipmentDeliveryByPrintingOrderAPITestCase(TestCase):
"""测试按生产订单查询送货单 API"""
def setUp(self):
self.client = APIClient()
self.merchant = basic_models.Merchant.objects.create(
name="送货查询商户", type=basic_models.MerchantTypeEnum.FACTORY
)
self.other_merchant = basic_models.Merchant.objects.create(
name="其它送货查询商户", type=basic_models.MerchantTypeEnum.FACTORY
)
self.user = User.objects.create_user(
username="delivery_by_order_user", password="testpass123"
)
self.employee = basic_models.Employee.objects.create(
sys_user=self.user,
merchant=self.merchant,
name="送货查询员工",
status=basic_models.EmployeeStatusEnum.ACTIVE,
)
self.customer = basic_models.Customer.objects.create(
merchant=self.merchant,
name="送货查询客户",
created_by=self.employee,
)
self.state = stateflow_models.State.objects.create(name="待送货查询")
self.process = stateflow_models.Process.objects.create(name="送货查询流程")
self.process.replace_nodes([self.state])
self.product = basic_models.Product.objects.create(
merchant=self.merchant,
category=basic_models.ProductCategory.objects.create(
merchant=self.merchant,
name="送货查询分类",
),
name="送货查询产品",
)
self.printing_order = printing_models.PrintingOrder.objects.create(
merchant=self.merchant,
customer=self.customer,
fabric="送货查询面料",
width="150cm",
process=self.process,
created_by=self.user,
external_order_id="EXT-DELIVERY-001",
)
self.printing_job1 = printing_models.PrintingJob.objects.create(
merchant=self.merchant,
printing_order=self.printing_order,
product=self.product,
quantity=100,
unit="米",
created_by=self.user,
)
self.printing_job2 = printing_models.PrintingJob.objects.create(
merchant=self.merchant,
printing_order=self.printing_order,
product=self.product,
quantity=80,
unit="米",
created_by=self.user,
)
self.delivery1 = shipment_models.ShipmentDelivery.objects.create(
merchant=self.merchant,
driver_name="张司机",
vehicle_trip="KD-001",
contact_phone="13800138000",
vehicle_capacity="9.6米厢车",
remark="外部备注A",
internal_remark="内部备注A",
status=shipment_models.ShipmentDeliveryStatus.IN_TRANSIT,
started_at=timezone.datetime(2026, 7, 1, 9, 0, tzinfo=timezone.get_current_timezone()),
created_by=self.user,
)
self.delivery2 = shipment_models.ShipmentDelivery.objects.create(
merchant=self.merchant,
driver_name="李司机",
vehicle_trip="KD-002",
contact_phone="13900139000",
vehicle_capacity="13米高栏",
remark="外部备注B",
internal_remark="内部备注B",
status=shipment_models.ShipmentDeliveryStatus.DELIVERED,
delivered_at=timezone.datetime(2026, 7, 3, 18, 0, tzinfo=timezone.get_current_timezone()),
created_by=self.user,
)
self.shipment1 = shipment_models.Shipment.objects.create(
merchant=self.merchant,
customer=self.customer,
shipment_date="2026-07-01",
delivery=self.delivery1,
created_by=self.user,
)
self.shipment2 = shipment_models.Shipment.objects.create(
merchant=self.merchant,
customer=self.customer,
shipment_date="2026-07-03",
delivery=self.delivery2,
created_by=self.user,
)
self.sales_item1 = shipment_models.SalesItem.objects.create(
merchant=self.merchant,
name="送货销售品1",
quantity=Decimal("10.00"),
unit=shipment_models.UnitChoices.METER,
printing_job_id=self.printing_job1.id,
shipment=self.shipment1,
customer_id=self.customer.id,
created_by=self.user,
)
self.sales_item2 = shipment_models.SalesItem.objects.create(
merchant=self.merchant,
name="送货销售品2",
quantity=Decimal("20.00"),
unit=shipment_models.UnitChoices.METER,
printing_job_id=self.printing_job1.id,
shipment=self.shipment1,
customer_id=self.customer.id,
created_by=self.user,
)
self.sales_item3 = shipment_models.SalesItem.objects.create(
merchant=self.merchant,
name="送货销售品3",
quantity=Decimal("30.00"),
unit=shipment_models.UnitChoices.METER,
printing_job_id=self.printing_job2.id,
shipment=self.shipment2,
customer_id=self.customer.id,
created_by=self.user,
)
other_order = printing_models.PrintingOrder.objects.create(
merchant=self.merchant,
customer=self.customer,
fabric="其它面料",
width="160cm",
process=self.process,
created_by=self.user,
external_order_id="EXT-OTHER-DELIVERY",
)
other_job = printing_models.PrintingJob.objects.create(
merchant=self.merchant,
printing_order=other_order,
product=self.product,
quantity=50,
unit="米",
created_by=self.user,
)
other_delivery = shipment_models.ShipmentDelivery.objects.create(
merchant=self.merchant,
driver_name="王司机",
vehicle_trip="KD-999",
created_by=self.user,
)
other_shipment = shipment_models.Shipment.objects.create(
merchant=self.merchant,
customer=self.customer,
shipment_date="2026-07-04",
delivery=other_delivery,
created_by=self.user,
)
shipment_models.SalesItem.objects.create(
merchant=self.merchant,
name="其它订单销售品",
quantity=Decimal("40.00"),
unit=shipment_models.UnitChoices.METER,
printing_job_id=other_job.id,
shipment=other_shipment,
customer_id=self.customer.id,
created_by=self.user,
)
self.client.force_authenticate(user=self.user)
def test_list_deliveries_by_internal_printing_order_id(self):
resp = self.client.get(
f"/api/v1/shipment/deliveries/by-printing-order/{self.printing_order.id}/"
)
self.assertEqual(resp.status_code, status.HTTP_200_OK)
data = resp.json()
self.assertEqual(data["count"], 2)
ids = {item["id"] for item in data["results"]}
self.assertEqual(ids, {self.delivery1.id, self.delivery2.id})
def test_list_deliveries_by_external_order_id(self):
resp = self.client.get(
"/api/v1/shipment/deliveries/by-printing-order/EXT-DELIVERY-001/"
)
self.assertEqual(resp.status_code, status.HTTP_200_OK)
data = resp.json()
self.assertEqual(data["count"], 2)
self.assertEqual(data["results"][0]["driver_name"], "李司机")
def test_list_deliveries_filters_driver_status_and_time_ranges(self):
resp = self.client.get(
f"/api/v1/shipment/deliveries/by-printing-order/{self.printing_order.id}/"
"?status=2&driver_name=张&vehicle_trip=KD-001&contact_phone=138"
"&vehicle_capacity=9.6&remark=外部备注A&internal_remark=内部备注A"
"&started_at_from=2026-07-01&started_at_to=2026-07-01"
"&shipment_date_from=2026-07-01&shipment_date_to=2026-07-01"
)
self.assertEqual(resp.status_code, status.HTTP_200_OK)
data = resp.json()
self.assertEqual(data["count"], 1)
self.assertEqual(data["results"][0]["id"], self.delivery1.id)
def test_list_deliveries_supports_pagination_and_ordering(self):
resp = self.client.get(
f"/api/v1/shipment/deliveries/by-printing-order/{self.printing_order.id}/"
"?ordering=id&limit=1&offset=1"
)
self.assertEqual(resp.status_code, status.HTTP_200_OK)
data = resp.json()
self.assertEqual(data["count"], 2)
self.assertEqual(len(data["results"]), 1)
self.assertEqual(data["results"][0]["id"], self.delivery2.id)
def test_list_deliveries_duplicate_external_order_id_returns_500(self):
printing_models.PrintingOrder.objects.create(
merchant=self.merchant,
customer=self.customer,
fabric="重复面料1",
width="150cm",
process=self.process,
created_by=self.user,
external_order_id="EXT-DELIVERY-DUP",
)
printing_models.PrintingOrder.objects.create(
merchant=self.merchant,
customer=self.customer,
fabric="重复面料2",
width="150cm",
process=self.process,
created_by=self.user,
external_order_id="EXT-DELIVERY-DUP",
)
resp = self.client.get(
"/api/v1/shipment/deliveries/by-printing-order/EXT-DELIVERY-DUP/"
)
self.assertEqual(resp.status_code, status.HTTP_500_INTERNAL_SERVER_ERROR)
self.assertIn("匹配到多个生产订单", resp.json()["message"])
class ShipmentSalesItemCustomersAPITestCase(TestCase):
"""测试由未出货销售品汇总客户 API"""
@@ -483,6 +804,39 @@ class ShipmentSalesItemCustomersAPITestCase(TestCase):
self.assertEqual(len(data["results"]), 1)
self.assertEqual(data["results"][0]["customer_id"], self.customer2.id)
def test_list_customers_with_unshipped_sales_items_filters_by_customer_name(self):
resp = self.client.get(
"/api/v1/shipment/sales-items/customers/?customer_name=客户A"
)
self.assertEqual(resp.status_code, status.HTTP_200_OK)
data = resp.json()
self.assertEqual(data["count"], 1)
self.assertEqual(data["results"][0]["customer_id"], self.customer1.id)
self.assertEqual(data["results"][0]["unshipped_sales_items_count"], 2)
def test_list_customers_with_unshipped_sales_items_filters_by_missing_customer_name(self):
resp = self.client.get(
"/api/v1/shipment/sales-items/customers/?customer_name=不存在"
)
self.assertEqual(resp.status_code, status.HTTP_200_OK)
data = resp.json()
self.assertEqual(data["count"], 0)
self.assertEqual(data["results"], [])
def test_list_customers_with_unshipped_sales_items_ignores_blank_customer_name(self):
resp = self.client.get(
"/api/v1/shipment/sales-items/customers/?customer_name=++"
)
self.assertEqual(resp.status_code, status.HTTP_200_OK)
data = resp.json()
self.assertEqual(data["count"], 2)
def test_list_customers_with_unshipped_sales_items_unauthenticated(self):
self.client.logout()
@@ -684,6 +1038,141 @@ class SalesItemByCustomerAPITestCase(TestCase):
self.assertEqual(set(result_ids), {self.sales_item1.id, self.sales_item2.id})
self.assertNotIn(other_sales_item.id, result_ids)
def test_get_sales_items_by_customer_group_groups_by_external_order_id_and_name(self):
duplicate_sales_item = shipment_models.SalesItem.objects.create(
merchant=self.merchant,
name="销售品1",
quantity=Decimal("11.00"),
unit=shipment_models.UnitChoices.METER,
printing_job_id=self.printing_job.id,
customer_id=self.customer.id,
created_by=self.user,
)
resp = self.client.get(
f"/api/v1/shipment/sales-items/by-customer/{self.customer.id}/group/"
)
self.assertEqual(resp.status_code, status.HTTP_200_OK)
data = resp.json()
self.assertEqual(data["count"], 1)
self.assertEqual(len(data["results"]), 1)
external_group = data["results"][0]
self.assertEqual(external_group["external_order_id"], "EXT-CUST-001")
self.assertEqual(external_group["count"], 3)
by_name = {group["name"]: group for group in external_group["name_groups"]}
self.assertEqual(by_name["销售品1"]["count"], 2)
self.assertEqual(by_name["销售品2"]["count"], 1)
self.assertEqual(
{item["id"] for item in by_name["销售品1"]["items"]},
{self.sales_item1.id, duplicate_sales_item.id},
)
def test_get_sales_items_by_customer_group_paginates_external_order_id_groups_with_null_last(self):
other_printing_order = printing_models.PrintingOrder.objects.create(
merchant=self.merchant,
customer=self.customer,
fabric="其它面料",
width="160cm",
process=self.process,
created_by=self.user,
external_order_id="EXT-CUST-OTHER",
)
other_printing_job = printing_models.PrintingJob.objects.create(
merchant=self.merchant,
printing_order=other_printing_order,
product=self.product,
quantity=50,
unit="米",
created_by=self.user,
)
shipment_models.SalesItem.objects.create(
merchant=self.merchant,
name="其它外部订单销售品",
quantity=Decimal("66.00"),
unit=shipment_models.UnitChoices.METER,
printing_job_id=other_printing_job.id,
customer_id=self.customer.id,
created_by=self.user,
)
shipment_models.SalesItem.objects.create(
merchant=self.merchant,
name="无外部订单销售品",
quantity=Decimal("77.00"),
unit=shipment_models.UnitChoices.METER,
customer_id=self.customer.id,
created_by=self.user,
)
first_page = self.client.get(
f"/api/v1/shipment/sales-items/by-customer/{self.customer.id}/group/"
"?limit=1&offset=0"
)
second_page = self.client.get(
f"/api/v1/shipment/sales-items/by-customer/{self.customer.id}/group/"
"?limit=1&offset=1"
)
third_page = self.client.get(
f"/api/v1/shipment/sales-items/by-customer/{self.customer.id}/group/"
"?limit=1&offset=2"
)
self.assertEqual(first_page.status_code, status.HTTP_200_OK)
self.assertEqual(second_page.status_code, status.HTTP_200_OK)
self.assertEqual(third_page.status_code, status.HTTP_200_OK)
self.assertEqual(first_page.json()["count"], 3)
self.assertEqual(
first_page.json()["results"][0]["external_order_id"], "EXT-CUST-001"
)
self.assertEqual(
second_page.json()["results"][0]["external_order_id"], "EXT-CUST-OTHER"
)
self.assertIsNone(third_page.json()["results"][0]["external_order_id"])
def test_get_sales_items_by_customer_group_supports_external_order_id_filter(self):
other_printing_order = printing_models.PrintingOrder.objects.create(
merchant=self.merchant,
customer=self.customer,
fabric="其它面料",
width="160cm",
process=self.process,
created_by=self.user,
external_order_id="EXT-CUST-OTHER",
)
other_printing_job = printing_models.PrintingJob.objects.create(
merchant=self.merchant,
printing_order=other_printing_order,
product=self.product,
quantity=50,
unit="米",
created_by=self.user,
)
other_sales_item = shipment_models.SalesItem.objects.create(
merchant=self.merchant,
name="其它外部订单销售品",
quantity=Decimal("66.00"),
unit=shipment_models.UnitChoices.METER,
printing_job_id=other_printing_job.id,
customer_id=self.customer.id,
created_by=self.user,
)
resp = self.client.get(
f"/api/v1/shipment/sales-items/by-customer/{self.customer.id}/group/"
"?external_order_id=EXT-CUST-OTHER"
)
self.assertEqual(resp.status_code, status.HTTP_200_OK)
data = resp.json()
self.assertEqual(data["count"], 1)
self.assertEqual(data["results"][0]["external_order_id"], "EXT-CUST-OTHER")
self.assertEqual(
data["results"][0]["name_groups"][0]["items"][0]["id"],
other_sales_item.id,
)
def test_get_sales_items_by_customer_not_found(self):
resp = self.client.get("/api/v1/shipment/sales-items/by-customer/99999/")
@@ -1283,7 +1772,9 @@ class ShipmentCreateAPITestCase(TestCase):
"address": "杭州市测试路 1 号",
"contact_name": "张三",
"contact_phone": "13800138000",
"area": "华东",
"area": "华东" * 25,
"coordinates": "120.1551,30.2741",
"extra": {"source": "customer_address", "tags": ["snapshot"]},
"remark": "测试备注",
"sales_items": [self.sales_item1.id, self.sales_item2.id],
}
@@ -1301,7 +1792,9 @@ class ShipmentCreateAPITestCase(TestCase):
self.assertEqual(result["address"], "杭州市测试路 1 号")
self.assertEqual(result["contact_name"], "张三")
self.assertEqual(result["contact_phone"], "13800138000")
self.assertEqual(result.get("area", ""), "华东")
self.assertEqual(result.get("area", ""), "华东" * 25)
self.assertEqual(result["coordinates"], "120.1551,30.2741")
self.assertEqual(result["extra"], {"source": "customer_address", "tags": ["snapshot"]})
self.assertEqual(result["remark"], "测试备注")
self.assertEqual(result["status"], shipment_models.ShipmentStatus.DRAFT)
self.assertEqual(result["status_display"], "草稿(未发布)")
@@ -1314,6 +1807,105 @@ class ShipmentCreateAPITestCase(TestCase):
self.assertEqual(self.sales_item1.shipment_id, result["id"])
self.assertEqual(self.sales_item2.shipment_id, result["id"])
def test_create_shipment_with_address_id_keeps_address_snapshot(self):
customer_address = basic_models.CustomerAddress.objects.create(
merchant=self.merchant,
customer=self.customer,
address="客户地址表地址",
contact_name="地址联系人",
contact_phone="13900139000",
area="地址地区",
created_by=self.employee,
)
data = {
"customer": self.customer.id,
"address_id": customer_address.id,
"shipment_date": "2026-01-14",
"address": "出货单快照地址",
"contact_name": "快照联系人",
"contact_phone": "13800138000",
"area": "快照地区",
"coordinates": "121.0000,31.0000",
"extra": {"floor": "3F"},
"sales_items": [self.sales_item1.id, self.sales_item2.id],
}
response = self.client.post("/api/v1/shipment/shipments/", data, format="json")
self.assertEqual(response.status_code, status.HTTP_201_CREATED)
result = response.json()
self.assertEqual(result["address_id"], customer_address.id)
self.assertEqual(result["address"], "出货单快照地址")
self.assertEqual(result["contact_name"], "快照联系人")
self.assertEqual(result["contact_phone"], "13800138000")
self.assertEqual(result["area"], "快照地区")
self.assertEqual(result["coordinates"], "121.0000,31.0000")
self.assertEqual(result["extra"], {"floor": "3F"})
shipment = shipment_models.Shipment.objects.get(id=result["id"])
self.assertEqual(shipment.customer_address_id, customer_address.id)
self.assertEqual(shipment.coordinates, "121.0000,31.0000")
self.assertEqual(shipment.extra, {"floor": "3F"})
def test_create_shipment_accepts_status(self):
data = {
"customer": self.customer.id,
"shipment_date": "2026-01-14",
"status": shipment_models.ShipmentStatus.APPROVED,
}
response = self.client.post("/api/v1/shipment/shipments/", data, format="json")
self.assertEqual(response.status_code, status.HTTP_201_CREATED)
result = response.json()
self.assertEqual(result["status"], shipment_models.ShipmentStatus.APPROVED)
self.assertEqual(result["status_display"], "已审核")
shipment = shipment_models.Shipment.objects.get(id=result["id"])
self.assertEqual(shipment.status, shipment_models.ShipmentStatus.APPROVED)
def test_create_shipment_rejects_mismatched_address_id(self):
other_customer = basic_models.Customer.objects.create(
merchant=self.merchant,
name="其它客户",
)
customer_address = basic_models.CustomerAddress.objects.create(
merchant=self.merchant,
customer=other_customer,
address="其它客户地址",
created_by=self.employee,
)
data = {
"customer": self.customer.id,
"address_id": customer_address.id,
"shipment_date": "2026-01-14",
}
response = self.client.post("/api/v1/shipment/shipments/", data, format="json")
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
self.assertIn("客户地址与客户不匹配", response.json()["detail"])
def test_create_shipment_rejects_deleted_address_id(self):
customer_address = basic_models.CustomerAddress.objects.create(
merchant=self.merchant,
customer=self.customer,
address="已删除客户地址",
deleted_at=timezone.now(),
deleted_by=self.employee,
created_by=self.employee,
)
data = {
"customer": self.customer.id,
"address_id": customer_address.id,
"shipment_date": "2026-01-14",
}
response = self.client.post("/api/v1/shipment/shipments/", data, format="json")
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
self.assertIn("已删除", response.json()["detail"])
@override_settings(TESTING=False, SHIPMENT_CREATED_WECOM_NOTIFY_ENABLED=True)
def test_create_shipment_enqueues_wecom_notification_task(self):
"""测试创建出货单后投递企业微信通知任务"""
@@ -1387,8 +1979,8 @@ class ShipmentCreateAPITestCase(TestCase):
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
self.assertIn("已关联", response.json()["detail"])
def test_create_shipment_rejects_sales_items_from_different_printing_orders(self):
"""测试销售品来自不同生产订单时拒绝创建"""
def test_create_shipment_allows_sales_items_from_different_printing_orders(self):
"""测试销售品可以来自不同生产订单"""
data = {
"customer": self.customer.id,
"shipment_date": "2026-01-14",
@@ -1397,8 +1989,14 @@ class ShipmentCreateAPITestCase(TestCase):
response = self.client.post("/api/v1/shipment/shipments/", data, format="json")
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
self.assertIn("同一个生产订单", response.json()["detail"])
self.assertEqual(response.status_code, status.HTTP_201_CREATED)
result = response.json()
self.assertEqual(result["items_count"], 2)
self.sales_item1.refresh_from_db()
self.sales_item_other_order.refresh_from_db()
self.assertEqual(self.sales_item1.shipment_id, result["id"])
self.assertEqual(self.sales_item_other_order.shipment_id, result["id"])
def test_create_shipment_rejects_sales_item_without_printing_job(self):
"""测试销售品缺少生产任务时拒绝创建"""
@@ -1846,6 +2444,8 @@ class ShipmentQueryAPITestCase(TestCase):
self.assertEqual(result["id"], self.shipment1.id)
self.assertIn("area", result)
self.assertEqual(result["area"], "A1")
self.assertIn("coordinates", result)
self.assertIn("extra", result)
self.assertEqual(result["status"], shipment_models.ShipmentStatus.DRAFT)
self.assertEqual(result["status_display"], "草稿(未发布)")
self.assertIn("sales_items", result)
@@ -1865,6 +2465,8 @@ class ShipmentQueryAPITestCase(TestCase):
"address": "宁波市滨海路 9 号",
"contact_name": "王五",
"contact_phone": "13700137000",
"coordinates": "120.2000,30.3000",
"extra": {"dock": "A"},
},
format="json",
)
@@ -1875,12 +2477,16 @@ class ShipmentQueryAPITestCase(TestCase):
self.assertEqual(result["address"], "宁波市滨海路 9 号")
self.assertEqual(result["contact_name"], "王五")
self.assertEqual(result["contact_phone"], "13700137000")
self.assertEqual(result["coordinates"], "120.2000,30.3000")
self.assertEqual(result["extra"], {"dock": "A"})
self.shipment1.refresh_from_db()
self.assertEqual(getattr(self.shipment1, "area", ""), "更新地区")
self.assertEqual(self.shipment1.address, "宁波市滨海路 9 号")
self.assertEqual(self.shipment1.contact_name, "王五")
self.assertEqual(self.shipment1.contact_phone, "13700137000")
self.assertEqual(self.shipment1.coordinates, "120.2000,30.3000")
self.assertEqual(self.shipment1.extra, {"dock": "A"})
def test_patch_shipment_allows_approved_shipment_without_delivery(self):
"""
@@ -1911,6 +2517,24 @@ class ShipmentQueryAPITestCase(TestCase):
self.shipment1.refresh_from_db()
self.assertEqual(self.shipment1.area, "审核后可修改")
def test_patch_shipment_allows_cancelled_shipment_without_delivery(self):
self.shipment1.status = shipment_models.ShipmentStatus.CANCELLED
self.shipment1.save(update_fields=["status", "updated_at"])
resp = self.client.patch(
f"/api/v1/shipment/shipments/{self.shipment1.id}/",
data={"area": "取消后可修改"},
format="json",
)
self.assertEqual(resp.status_code, status.HTTP_200_OK)
self.assertEqual(resp.json()["area"], "取消后可修改")
self.assertEqual(resp.json()["status"], shipment_models.ShipmentStatus.CANCELLED)
self.shipment1.refresh_from_db()
self.assertEqual(self.shipment1.area, "取消后可修改")
self.assertEqual(self.shipment1.status, shipment_models.ShipmentStatus.CANCELLED)
def test_patch_shipment_rejects_when_bound_to_delivery(self):
delivery = shipment_models.ShipmentDelivery.objects.create(
merchant=self.merchant1,

427
api_v1/views/shipment/views.py
View File

@@ -8,6 +8,7 @@ from rest_framework.mixins import ListModelMixin, RetrieveModelMixin
from rest_framework.permissions import IsAuthenticated
from rest_framework.response import Response
from rest_framework.views import APIView
from django.utils.dateparse import parse_date, parse_datetime
from flower.viewsets import LimitedLimitOffsetPagination
from shipment.models import Shipment, ShipmentDelivery
@@ -19,6 +20,7 @@ from .serializers import (
SalesItemUpdateSerializer,
ShipmentStatusUpdateSerializer,
ShipmentDeliveryBindShipmentsSerializer,
ShipmentDeliveryByPrintingOrderSerializer,
ShipmentDeliveryCreateSerializer,
ShipmentDeliverySerializer,
ShipmentDeliveryStatusUpdateSerializer,
@@ -210,11 +212,15 @@ class ShipmentListCreateView(ListModelMixin, GenericAPIView):
shipment_date=data["shipment_date"],
sales_item_ids=data["sales_items"],
created_by=request.user,
address_id=data.get("address_id"),
address=data.get("address", ""),
contact_name=data.get("contact_name", ""),
contact_phone=data.get("contact_phone", ""),
remark=data.get("remark", ""),
area=data.get("area", ""),
coordinates=data.get("coordinates"),
extra=data.get("extra"),
status=data.get("status"),
)
except ValueError as e:
return Response({"detail": str(e)}, status=status.HTTP_400_BAD_REQUEST)
@@ -274,7 +280,7 @@ class ShipmentDetailView(RetrieveModelMixin, GenericAPIView):
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
data = serializer.validated_data
from shipment.services import update_shipment
from shipment.services import UNSET, update_shipment
try:
shipment = update_shipment(
@@ -285,8 +291,10 @@ class ShipmentDetailView(RetrieveModelMixin, GenericAPIView):
contact_name=data.get("contact_name"),
contact_phone=data.get("contact_phone"),
area=data.get("area"),
coordinates=data["coordinates"] if "coordinates" in data else UNSET,
remark=data.get("remark"),
external_id=data.get("external_id"),
extra=data["extra"] if "extra" in data else UNSET,
)
except ValueError as e:
return Response({"detail": str(e)}, status=status.HTTP_400_BAD_REQUEST)
@@ -444,6 +452,172 @@ class ShipmentDeliveryListCreateView(ListModelMixin, GenericAPIView):
)
class ShipmentDeliveryByPrintingOrderView(GenericAPIView):
"""
按生产订单查询相关送货单。
GET /api/v1/shipment/deliveries/by-printing-order/<printing_order_id>/
"""
permission_classes = [IsAuthenticated]
serializer_class = ShipmentDeliveryByPrintingOrderSerializer
pagination_class = LimitedLimitOffsetPagination
ordering_fields = {
"id",
"created_at",
"updated_at",
"started_at",
"delivered_at",
"cancelled_at",
"status",
}
def _get_merchant_limited_printing_orders(self):
from printing.models import PrintingOrder
queryset = PrintingOrder.objects.all()
user = self.request.user
if getattr(user, "is_superuser", False):
return queryset
emp = getattr(user, "employee", None)
merchant = getattr(emp, "merchant", None) if emp else None
if not merchant:
return queryset.none()
return queryset.filter(merchant=merchant)
def _resolve_printing_order(self, printing_order_id: str):
raw_value = str(printing_order_id).strip()
base_queryset = self._get_merchant_limited_printing_orders()
if raw_value.isdigit():
printing_order = base_queryset.filter(id=int(raw_value)).first()
if printing_order is not None:
return printing_order, None
matched_orders = list(
base_queryset.filter(external_order_id=raw_value).only("id", "merchant_id")[:2]
)
if len(matched_orders) > 1:
return None, Response(
{
"message": (
f"external_order_id {raw_value} 匹配到多个生产订单，"
"请改用内部ID查询"
)
},
status=status.HTTP_500_INTERNAL_SERVER_ERROR,
)
if len(matched_orders) == 1:
return matched_orders[0], None
return None, Response(
{"detail": f"生产订单 {printing_order_id} 不存在"},
status=status.HTTP_404_NOT_FOUND,
)
def _apply_datetime_range(self, queryset, field_name: str, from_param: str, to_param: str):
start_value = (self.request.query_params.get(from_param) or "").strip()
if start_value:
if "T" in start_value or ":" in start_value:
parsed = parse_datetime(start_value)
if parsed is not None:
queryset = queryset.filter(**{f"{field_name}__gte": parsed})
else:
parsed = parse_date(start_value)
if parsed is not None:
queryset = queryset.filter(**{f"{field_name}__date__gte": parsed})
end_value = (self.request.query_params.get(to_param) or "").strip()
if end_value:
if "T" in end_value or ":" in end_value:
parsed = parse_datetime(end_value)
if parsed is not None:
queryset = queryset.filter(**{f"{field_name}__lte": parsed})
else:
parsed = parse_date(end_value)
if parsed is not None:
queryset = queryset.filter(**{f"{field_name}__date__lte": parsed})
return queryset
def _apply_filters(self, queryset):
status_val = self.request.query_params.get("status")
if status_val:
queryset = queryset.filter(status=status_val)
for field_name in [
"driver_name",
"vehicle_trip",
"contact_phone",
"vehicle_capacity",
"remark",
"internal_remark",
]:
value = (self.request.query_params.get(field_name) or "").strip()
if value:
queryset = queryset.filter(**{f"{field_name}__icontains": value})
queryset = self._apply_datetime_range(
queryset, "started_at", "started_at_from", "started_at_to"
)
queryset = self._apply_datetime_range(
queryset, "delivered_at", "delivered_at_from", "delivered_at_to"
)
queryset = self._apply_datetime_range(
queryset, "cancelled_at", "cancelled_at_from", "cancelled_at_to"
)
queryset = self._apply_datetime_range(
queryset, "created_at", "created_at_from", "created_at_to"
)
shipment_date_from = (self.request.query_params.get("shipment_date_from") or "").strip()
if shipment_date_from:
queryset = queryset.filter(shipments__shipment_date__gte=shipment_date_from)
shipment_date_to = (self.request.query_params.get("shipment_date_to") or "").strip()
if shipment_date_to:
queryset = queryset.filter(shipments__shipment_date__lte=shipment_date_to)
ordering = (self.request.query_params.get("ordering") or "").strip()
if ordering:
normalized = ordering[1:] if ordering.startswith("-") else ordering
if normalized in self.ordering_fields:
return queryset.order_by(ordering, "-id").distinct()
return queryset.order_by("-created_at", "-id").distinct()
def get(self, request, printing_order_id: str):
printing_order, error_response = self._resolve_printing_order(printing_order_id)
if error_response is not None:
return error_response
from printing.models import PrintingJob
printing_job_ids = list(
PrintingJob.objects.filter(printing_order=printing_order).values_list(
"id", flat=True
)
)
if not printing_job_ids:
queryset = ShipmentDelivery.objects.none()
else:
queryset = (
ShipmentDelivery.objects.filter(
merchant=printing_order.merchant,
shipments__items__printing_job_id__in=printing_job_ids,
shipments__items__delete_at__isnull=True,
)
.select_related("merchant", "created_by", "operator", "cancelled_by")
.prefetch_related("shipments", "shipments__customer")
)
queryset = self._apply_filters(queryset)
page = self.paginate_queryset(queryset)
serializer = self.get_serializer(page if page is not None else queryset, many=True)
if page is not None:
return self.get_paginated_response(serializer.data)
return Response(serializer.data)
class ShipmentDeliveryDetailView(RetrieveModelMixin, GenericAPIView):
"""
送货单详情 / 修改 / 删除
@@ -712,6 +886,8 @@ class ShipmentExternalCreateView(APIView):
contact_phone=data.get("contact_phone", ""),
remark=data.get("remark", ""),
area=data.get("area", ""),
coordinates=data.get("coordinates"),
extra=data.get("extra"),
)
except ValueError as e:
return Response({"detail": str(e)}, status=status.HTTP_400_BAD_REQUEST)
@@ -753,7 +929,15 @@ class ShipmentSalesItemCustomerListView(GenericAPIView):
from shipment.services import get_customers_with_unshipped_sales_items
return get_customers_with_unshipped_sales_items(merchant=merchant)
qs = get_customers_with_unshipped_sales_items(merchant=merchant)
customer_name = self.request.query_params.get("customer_name")
if customer_name:
customer_name = customer_name.strip()
if customer_name:
qs = qs.filter(name__icontains=customer_name)
return qs
def get(self, request):
queryset = self.get_queryset()
@@ -872,6 +1056,134 @@ class SalesItemByPrintingOrderView(APIView):
return Response({"count": len(serializer.data), "results": serializer.data})
class SalesItemByPrintingOrderGroupView(SalesItemByPrintingOrderView):
"""
通过生产订单查询销售品，并按 printing_job_id 分组分页。
GET /api/v1/shipment/sales-items/by-printing-order/<printing_order_id>/group/
"""
pagination_class = LimitedLimitOffsetPagination
@property
def paginator(self):
if not hasattr(self, "_paginator"):
self._paginator = self.pagination_class()
return self._paginator
def paginate_queryset(self, queryset):
return self.paginator.paginate_queryset(queryset, self.request, view=self)
def get_paginated_response(self, data):
return self.paginator.get_paginated_response(data)
def get(self, request, printing_order_id):
from printing.models import PrintingOrder
user = request.user
if getattr(user, "is_superuser", False):
base_queryset = PrintingOrder.objects.all()
else:
emp = getattr(user, "employee", None)
merchant = getattr(emp, "merchant", None) if emp else None
if not merchant:
return Response(
{"detail": f"生产订单 {printing_order_id} 不存在"},
status=status.HTTP_404_NOT_FOUND,
)
base_queryset = PrintingOrder.objects.filter(merchant=merchant)
printing_order = None
if printing_order_id.isdigit():
printing_order = base_queryset.filter(id=int(printing_order_id)).first()
if printing_order is None:
matched_orders = list(
base_queryset.filter(external_order_id=printing_order_id).only("id")[:2]
)
if len(matched_orders) > 1:
return Response(
{
"detail": (
f"external_order_id {printing_order_id} 匹配到多个生产订单，"
"请改用内部ID查询"
)
},
status=status.HTTP_400_BAD_REQUEST,
)
if len(matched_orders) == 1:
printing_order = matched_orders[0]
if printing_order is None:
return Response(
{"detail": f"生产订单 {printing_order_id} 不存在"},
status=status.HTTP_404_NOT_FOUND,
)
include_already_has_shipment = (
request.query_params.get("include_already_has_shipment", "false").lower()
== "true"
)
from shipment.services import get_sales_items_by_printing_order
queryset = get_sales_items_by_printing_order(
printing_order_id=printing_order_id,
include_already_has_shipment=include_already_has_shipment,
merchant=printing_order.merchant,
)
all_items = list(queryset)
printing_job_ids = []
seen_printing_job_ids = set()
for item in all_items:
group_key = item.printing_job_id
if group_key not in seen_printing_job_ids:
seen_printing_job_ids.add(group_key)
printing_job_ids.append(group_key)
printing_job_ids.sort(key=lambda value: (value is None, value or 0))
page_printing_job_ids = self.paginate_queryset(printing_job_ids)
selected_printing_job_ids = (
page_printing_job_ids
if page_printing_job_ids is not None
else printing_job_ids
)
selected_printing_job_id_set = set(selected_printing_job_ids)
selected_items = [
item
for item in all_items
if item.printing_job_id in selected_printing_job_id_set
]
serializer = SalesItemSerializer(
selected_items,
many=True,
context=_build_sales_item_serializer_context(selected_items),
)
grouped_by_printing_job_id = {
printing_job_id: {
"printing_job_id": printing_job_id,
"count": 0,
"items": [],
}
for printing_job_id in selected_printing_job_ids
}
for item in serializer.data:
printing_job_id = item["printing_job_id"]
group = grouped_by_printing_job_id[printing_job_id]
group["count"] += 1
group["items"].append(item)
groups = [
grouped_by_printing_job_id[printing_job_id]
for printing_job_id in selected_printing_job_ids
]
if page_printing_job_ids is not None:
return self.get_paginated_response(groups)
return Response(groups)
class SalesItemByCustomerView(GenericAPIView):
"""
通过客户查询销售品。
@@ -931,6 +1243,117 @@ class SalesItemByCustomerView(GenericAPIView):
return Response(serializer.data)
class SalesItemByCustomerGroupView(SalesItemByCustomerView):
"""
通过客户查询销售品，并按 external_order_id、name 分组。
GET /api/v1/shipment/sales-items/by-customer/<customer_id>/group/
"""
def get(self, request, customer_id: int):
from basic_info.models import Customer
user = request.user
if getattr(user, "is_superuser", False):
customer = Customer.objects.filter(id=customer_id).first()
else:
emp = getattr(user, "employee", None)
merchant = getattr(emp, "merchant", None) if emp else None
if not merchant:
return Response(
{"detail": f"客户 {customer_id} 不存在"},
status=status.HTTP_404_NOT_FOUND,
)
customer = Customer.objects.filter(id=customer_id, merchant=merchant).first()
if customer is None:
return Response(
{"detail": f"客户 {customer_id} 不存在"},
status=status.HTTP_404_NOT_FOUND,
)
include_already_has_shipment = (
request.query_params.get("include_already_has_shipment", "false").lower()
== "true"
)
external_order_id = (request.query_params.get("external_order_id") or "").strip()
from shipment.services import get_sales_items_by_customer
queryset = get_sales_items_by_customer(
merchant=customer.merchant,
customer_id=customer.id,
include_already_has_shipment=include_already_has_shipment,
external_order_id=external_order_id or None,
)
all_items = list(queryset)
serializer_context = _build_sales_item_serializer_context(all_items)
serialized_items = self.get_serializer(
all_items,
many=True,
context=serializer_context,
).data
external_order_ids = []
seen_external_order_ids = set()
for item in serialized_items:
group_key = item["external_order_id"]
if group_key not in seen_external_order_ids:
seen_external_order_ids.add(group_key)
external_order_ids.append(group_key)
external_order_ids.sort(key=lambda value: (value is None, value or ""))
page_external_order_ids = self.paginate_queryset(external_order_ids)
selected_external_order_ids = (
page_external_order_ids
if page_external_order_ids is not None
else external_order_ids
)
selected_external_order_id_set = set(selected_external_order_ids)
grouped_by_external_order_id = {
external_order_id: {
"external_order_id": external_order_id,
"count": 0,
"name_groups": [],
}
for external_order_id in selected_external_order_ids
}
name_group_maps = {
external_order_id: {} for external_order_id in selected_external_order_ids
}
for item in serialized_items:
external_order_id = item["external_order_id"]
if external_order_id not in selected_external_order_id_set:
continue
external_group = grouped_by_external_order_id[external_order_id]
external_group["count"] += 1
name = item["name"]
name_group_map = name_group_maps[external_order_id]
if name not in name_group_map:
name_group_map[name] = {
"name": name,
"count": 0,
"items": [],
}
external_group["name_groups"].append(name_group_map[name])
name_group = name_group_map[name]
name_group["count"] += 1
name_group["items"].append(item)
groups = [
grouped_by_external_order_id[external_order_id]
for external_order_id in selected_external_order_ids
]
if page_external_order_ids is not None:
return self.get_paginated_response(groups)
return Response(groups)
class SalesItemCreateView(APIView):
"""
手动创建销售品