現場で使っているDRFのアーキテクチャ

.
├── xxxxxx -> サービス名
│   ├── model
│   │   ├── ex -> 後述
│   │   │   ├── shop_ex.py
│   │   │   ├── customer_ex.py
│   │   │   └── order_ex.py
│   │   ├── shop.py
│   │   ├── customer.py
│   │   └── order.py
│   ├── url
│   │   ├── customer.py
│   │   └── shop.py
│   ├── view
│   │   ├── customer.py
│   │   └── shop.py
│   ├── serializer
│   │   ├── customer.py
│   │   └── shop.py
│   ├── commands
│   ├── migrations
│   ├── tests
│   └── common -> メール通知など、Model操作と紐づかないビジネスロジックを書く
│       ├── email.py
│       └── slack.py
│  
├── lib -> ビジネスロジックが存在しない/外部公開をしても問題のない処理
│   ├── utils -> 採用しているライブラリの拡張/根底クラス
│   │   └── serializers.vue
│   │   └── models.vue
│   │   ├── datetime.py
│   │   └── pandas.py
│   ├── pdf.py
│   ├── csv.py
│   └── convert.py
│  
└── config

class OrderViewSet(_ShopBaseViewSet, 
		   mixins.ListModelMixin, 
		   mixins.RetrieveModelMixin, 
		   mixins.CreateModelMixin):
    """
    注文マスタ
    """
    def get_serializer_class(self):
        if self.action in ['list', 'retrieve']:
            return serializers.OrderReadSerializer
        elif self.action in ['create']:
            return serializers.OrderCreateSerializer
        elif self.action in ['summary']:
            return serializers.OrderSummarySerializer
        else:
	    raise Http404

    def get_queryset(self):
        # ここには原則何も書かない
	# filter条件とかは、全てModelExの仕事
        return OrderEx.get_queryset_for_shop(shop=self.get_shop())
	
    @action(methods=["get"], detail=True)
    def dl_csv(self, request, *args, **kwargs):
        # ファイルダウンロードとかはこんな感じで書く。
	# CRUD群と同じviewクラスに入れとくと、
	# get_object()やget_quryset()を共通で使用しやすいので、権限漏れの心配も少なくなる
        target_order = self.get_object()
	file_path = target_order.create_csv()
	# file_response()
        return self.file_response(file_path)
	
    @action(methods=["get"], detail=False)
    def summary(self, request, *args, **kwargs):
        serializer = self.get_serializer(self.get_shop())
        return Response(serializer.data)

class OrderReadSerializer(_BaseShopModelSerializer, 
			  _BaseReadOnlySerializer):
    class _OrderRecordSerializer(serializers.ModelSerializer):
        class Meta:
            model = OrderRecord
            fields = ('id',　'quantity',　'product_code',　'product_name', 
	              'product_unit', 'product_price',　'product_tax_rate')
		      
    records = _OrderRecordSerializer(many=True)
    customer_code = serializers.CharField()
    class Meta:
        model = Order
        fields = ('id', 'customer_code', 'customer_user_name',
	          'delivery_date', 'order_date', 'is_first_order',
		  'records')


class ShopOrdersWriteSerializer(_BaseShopModelSerializer,
                                _BaseWriteOnlySerializer):
				
    class _OrderRecordSerializer(_BaseShopModelSerializer):
        class Meta:
            model = OrderRecord
            fields = ('product', 'quantity')
	    
        def validate_quantity(self, quantity):
            if quantity <= 0 :
                raise serializers.ValidationError('quantityは0より大きい数字にしてください')
            return quantity
	    
    records = serializers.ListSerializer(
			 child=_OrderRecordSerializer(),
                         required=True)
    class Meta:
        model = Order
        fields = ('customer', 'delivery_date', 'records')
	
    def validate_customer(self, customer):
        # modelにアクセスする系のバリデーションは、ModelExを通す
        if self.shop not in customerEx.get_queryset_for_shop(shop=shop):
	    raise serializers.ValidationError('注文できないshopです')
        return customer

    def create(self, validated_data):
        # ModelExを呼ぶだけ
        order = OrderEx.create_(customer=validated_data['customer'],					shop=self.get_shop(), 
			delivery_date=validated_data['delivery_date'],
			order_date=DateTimeUtil.now())
	
	## bulk_createしたいなら、こんな感じで書く
	## 少々冗長だが、ビジネスロジックが書かれているわけではないので良しとする
	## ModelExにbulk_create()作ってもいい
        order_record_bulk_create_object_list = []
        for record in validated_data['records']:
            order_record_object = OrderRecordEx.create_(order=order,
                                                        product=record['product'],
                                                        quantity=record['quantity'],
                                                        is_skip_save=True)
            order_record_bulk_create_object_list.append(order_record_object)
        OrderRecord.objects.bulk_create(order_record_bulk_create_object_list)
	
	## メール送信とかはここらへん
	
        return order

import Order from xxxxx.models

class OrderEx(Order):
    class Meta:
        proxy = True

    @classmethod
    def get_queryset_for_shop(cls, shop, target_customer=None):
        """
	注文参照。shopに紐づく注文を返す
	"""
	assert shop, 'shop is required'
	assert shop.is_active, 'this shop is not active'
	
        ## ビジネスロジックはここに書く
	## 他のModelExクラスをよんでOK
	## Viewのget_querysetから呼び出されることが多い
	
        return cls.objects.filter(shop=shop, 
				  target_customer=target_customer,
				  is_deleted=False).filter(q)

    @classmethod
    def create_(cls, customer, target_shop, order_date, deliver_date, 
		is_skip_save=False):
	"""
	注文作成
	is_skip_save: 使用ケースとしては、本関数のビジネスロジックを使用したいが、
		      本関数の外で、createやbulk_createする方がいい時用に使う。
	              save()をせず、orderオブジェクトを返す。
	"""
        # 初めての注文ならフラグ立たせとく(分かりやすくするために、変な書き方してます)
        if customer.has_ordered(shop=target_shop):
	    is_first_order = True
	else:
	    is_first_order = False
	# bulk_createしたい際などがあり、
	# 即時sql発行して欲しくないので、objects.create()は使わない。
        order = cls(target_shop=target_shop,
		    order_date=order_date,
		    deliver_date=deliver_date,
		    is_first_order=is_first_order)
	if not is_skip_save:
	    order.save()
	retunr order
	
   @classmethod
    def get_csv(cls, customer):
	## 省略