CODEWITHSUNDEEP
pythonangularjsdjangorestdjango-rest-framework
dkhaupt
dkhaupt

Reputation: 2348

How to think about Django's normal class based views vs. using a REST API

I've been writing a webapp with Django to replace a clumsy, spreadsheet based sports picking game that I play with some friends. I've learned a lot, and had a great time getting to know Django and how to build something like this from scratch.

I recently realized that I wanted to use something more powerful on the frontend (Ember, Angular, etc) with the end goal being a single page app. To that end, I installed Django REST Framework (DRF) and started reading the docs and following the tutorial. It's super interesting, and I'm finally starting to see why a client-server model with an API is really the only way to achieve the smooth interactivity that's all over now.

I'm trying to implement one of my class based views as an API endpoint, and I've been having a lot of trouble conceptualizing it. I thought I'd start with a simple, GET-only endpoint- here's the simple CBV I'm trying to replicate in API form:

class MatchupDetail(DetailView):
  template_name = 'app/matchups.html'
  context_object_name = 'pick_sheet'

  def get_object(self):
    #logic to find and return object

  def get_opponent(self,username,schedule,week, **kwargs):
    #logic to find and return the opponent in the matchup

  def get_context_data(self, **kwargs):
    context = super().get_context_data(**kwargs)
    #logic to pull the opponents details and set them in the context

I feel like I have a handle on this flow- a user clicks a link, and this view retrieves the object at the heart of the requested page, supplements it with content in the context, then renders it.

As I began thinking about turning this into an API endpoint, it didn't make a whole lot of sense. Should I be putting all the user-related data into a single JSON response? Or should the frontend basically handle the flow of this logic and the API simply be composed of a collection of endpoints- for example, one to retrieve the object, and one or more to retrieve what's now being passed in the context?

What prompted me to make this post was some trouble with my (super basic) API implementation of the above view:

class MatchupDetailApi(generics.ListAPIView):

  queryset = Sheet.objects.all()
  serializer_class = SheetSerializer

With serializer:

class SheetSerializer(serializers.ModelSerializer):
  user = serializers.ReadOnlyField()

  class Meta:
    model = Sheet

I added the user field when I noticed that without it, the returned serialized Sheet objects are literally just the row in the database- an integer ID, integer foreign key to the User object, and so on. With a 'traditional' CBV, the entire objects are returned to the template- so it's very intuitive to access related fields, and with Django it's also easy to traverse object relationships.

Does a REST implementation offer the same sort of thing? From what I've read, it seems like I'll need an extension to DRF (django-rest-multiple-models) to return more than one model in a single response, which leads me to think I should be creating endpoints for every model, and leaving presentation logic to when I take care of the frontend. Is that typical? Or is it feasible to have an API endpoint that does return something like an object and several related objects?

Note: the basic endpoint above stopped working when I added the user to the SheetSerializer. I realized I should have a UserSerializer as well, which is: 

class UserSerializer(serializers.HyperlinkedModelSerializer):
  class Meta:
    model = User

However, when I try to browse the API, i get a TypeError that the first user isn't serializable. Specifically: <User: dkhaupt> is not JSON serializable. Isn't this what the UserSerializer is for?

Upvotes: 2

Views: 932

Answers (2)

Emad Mokhtar
Emad Mokhtar

Reputation: 3297

You can add fields from another related model using the source attribute.

for example:

class SheetSerializer(serializers.ModelSerializer):
  user_id = serializers.ReadOnlyField(source='user.user_id')
  username = serializers.ReadOnlyField(source='user.username')

  class Meta:
    model = Sheet

Here the serializer will return the information from the user model that is related to the Sheet model.

Upvotes: 1

djq
djq

Reputation: 15286

Is it feasible to have an API endpoint that does return something like an object and several related objects?

Yes!

And it sounds like you are off to a great start. I would structure it something like this:

class UserSerializer(serializers.ModelSerializer):
    """serializes a user"""
    class Meta:
        model = User
        fields = ('id', 'first_name', 'last_name',)


class SheetSerializer(serializers.ModelSerializer):
    """serializes a sheet, and nests user relationship"""
    user = UserSerializer(read_only=True)

    class Meta:
        model = Sheet
        fields = ('id', 'sheet_name', 'user',)

I don't think you need django-rest-multiple-models for what you are trying to achieve. In my sketch (where I'm guessing fieldnames) you will serialize the sheet, and also the associated user object.

Upvotes: 2

Related Questions