models.py

class OpeningHours(models.Model):
    store = models.ForeignKey('Store', related_name="opening_hour")
    weekday = models.CharField(choices=DAY, max_length=12)
    opening_hour = models.TimeField()
    closing_hour = models.TimeField()

    class Meta:
    	verbose_name = 'Opening Hour'
    	verbose_name_plural = 'Opening Hours'

    def ___str__(self):
        return '{} {} - {}'.format(self.weekday, str(self.opening_hour), str(self.closing_hour))

class Store(models.Model):
    merchant = models.ForeignKey(User, blank=True, null=False)
    token = models.CharField(default=token_generator, max_length=20, unique=True, editable=False)
    name_of_legal_entity = models.CharField(max_length=250, blank=False, null=False)
    pan_number = models.CharField(max_length=20, blank=False, null=False)
    registered_office_address = models.CharField(max_length=200)
    name_of_store = models.CharField(max_length=100)
    email = models.EmailField(blank=False, null=False)
    store_contact_number = models.PositiveIntegerField(blank=False, null=False)
    is_active = models.BooleanField(default=True)

serializers.py

class EagerLoadingMixin:
    @classmethod
    def setup_eager_loading(cls, queryset):
        if hasattr(cls, "_SELECT_RELATED_FIELDS"):
            queryset = queryset.select_related(*cls._SELECT_RELATED_FIELDS)
        if hasattr(cls, "_PREFETCH_RELATED_FIELDS"):
            queryset = queryset.prefetch_related(*cls._PREFETCH_RELATED_FIELDS)
        return queryset

class ProductImageSerializer(serializers.ModelSerializer):
    class Meta:
        model = ProductImage
        fields = "__all__"
        read_only_fields = ('updated', )

class OpeningHoursSerializer(serializers.ModelSerializer):
    class Meta:
        model = OpeningHours
        fields = "__all__"


class ProductSerializer(serializers.ModelSerializer, EagerLoadingMixin):
    # _PREFETCH_RELATED_FIELDS = ['image',]
    class Meta:
        model = Product
        exclude = ('is_active', )

class StoreSerializer(serializers.ModelSerializer, EagerLoadingMixin):
    _SELECT_RELATED_FIELDS = ['merchant', ]
    # product = ProductSerializer(many=True)
    opening_hour = OpeningHoursSerializer(many=True)
    id = serializers.CharField(source='token', read_only=True)
    class Meta:
        model = Store
        exclude = ('is_active', )

views.py

class StoreView(APIView):
    serializer_class = StoreSerializer
    def get(self, request, token=None, format=None):
        """
        Return a list of all stores.
        """
        reply = {}
        try:
            stores = Store.objects.all()
            if token:
                store = stores.get(token=token)
                reply['data'] = self.serializer_class(store).data
            reply['data'] = self.serializer_class(stores, many=True).data
        except:
            reply['data'] = []
        return Response(reply, status.HTTP_200_OK)

    def post(self, request, format=None):
        """
        Post store
        """
        store = None
        reply={}
        if not token is None:
            try:
                store = Store.objects.get(token=token)
            except Store.DoesNotExist:
                return error.RequestedResourceNotFound().as_response()
            except:
                return error.UnknownError().as_response()
        serialized_data = self.serializer_class(instance=store, data=request.data, partial=True)
        if serialized_data.is_valid():
            serialized_data.save(merchant=request.user)
        else:
            return error.ValidationError(serialized_data.errors).as_response()
        return self.get(request)

Use the above for reference.