Querying

Lets get to finding stuff from the database. First, we need to show all the todo items in our database for our Todos.get function:

# Inside app.py
class Todos(rest.Resource):
    def get(self):
        """Will give you all the todo items"""

        with orm.db_session:  # 1
            return {
                item.id: {
                    'task': item.data,
                    'tags': [tag.id for tag in item.tags]  # 3
                }
                for item in Todo.select()  # 2
            }

We are using a context manager, orm.db_session in 1. This treats everything that pony does within the code-block as a transaction, you don't have to worry about committing. We are going to return a list of all the items according to their id, we have the 'task' value in the return dictionary provide the information regarding the Todo item. As for 'tags' we loop through the values in the item's tags and give the id. Note that in 2, we are looping through all the Todo items in the database, Todo.select() is the same as orm.select(tdo for tdo in Todo).

However, the id of the tags alone are not enough information about the tags associated with a certain Todo item, it would be better if we could generate links to the tag pages. We can actually add a property inside Tag as url:

# Inside models.py

(...)
@property
def url(self):
    return "http://localhost:5000/tags/{}".format(self.id)
(...)

We use property because we will be able to access it as if it were any other attribute.

Now that we have added this property, we can call the url property instead of the id:

# Inside app.py
(...)
'tags': [tag.url for tag in item.tags]  # 3
(...)

Now that this is done, lets send a GET request to the / url:

quazinafiulislam@Nafiuls-Mac: ~
 $ http GET http://localhost:5000/
HTTP/1.0 200 OK
Content-Length: 3
Content-Type: application/json
Date: Thu, 09 Oct 2014 10:32:00 GMT
Server: Werkzeug/0.9.6 Python/2.7.6

{}

Creating Objects

So that (probably) works! We won't know until we've added a Todo item. We haven't inserted anything into our database yet so lets do that. We are going to be accepted PUT requests for our / route. In order to do this, we need to import the json module, as well as flask.request:

# Inside app.py
import json  # New import

from flask import Flask, request  # New import
import flask.ext.restful as rest
(...)

Lets start by working on our Todos.put function. This is how the data is going to come in:

{
    "data": "Buy Milk!",
    "tags": ["work", "high"]
}

In order to make this function work, we need to do a couple of things:

• Extract data and tags from the json request.
• Create a new Todo item.
• Create new tags, if tags exist, then you need to use them instead of creating new ones.

In order to fulfill those roles, this is the function I ended up with:

# Inside app.py
(...)
def put(self):
    """Payload contains information to create new todo item"""

    info = json.loads(request.data)  # 1

    with orm.db_session:  # 2
        item = Todo(data=info['data'])  # 3

        for tag_name in info['tags']:  # 4
            tag = Tag.get(name=tag_name)  # 5
            if tag is None:  # 6
                tag = Tag(name=tag_name)  # 7
            item.tags += tag  # 8

    return {}, 200  # 9
(...)

In 1 we are loading the data from request.data, and turning that json string into a python dictionary. After doing so, we start our database session by using the orm.db_session context manager in 2.

We start off in 3 by creating a new Todo item. Note that our arguments are named/keyword arguments. We now loop over all the values in values in info['tags'] using tag_name as the temporary variable in 4.

In 5, we try to retrieve the tag if it exists in the database. If it doesn't 6, then we create a new one in 7. We then append this tag to the item's list of tags in 8.

In 9 we return an empty json object, with a 200 code, to say that everything happened smoothly. Note that in this entire function, it feels like there's no database. I just find this amazing that I feel as if I'm working with native python object stored in memory.

quazinafiulislam@Nafiuls-Mac: ~
 $ http PUT http://localhost:5000/ data="Buy rice" tags:='["work", "high"]'
HTTP/1.0 200 OK
Content-Length: 3
Content-Type: application/json
Date: Thu, 09 Oct 2014 11:36:04 GMT
Server: Werkzeug/0.9.6 Python/2.7.6

{}

Yay! So that worked. Or did it? Lets go back to our home page at / and lets see whats up:

quazinafiulislam@Nafiuls-Mac: ~
 $ http GET http://localhost:5000/
HTTP/1.0 200 OK
Content-Length: 166
Content-Type: application/json
Date: Sat, 11 Oct 2014 02:33:24 GMT
Server: Werkzeug/0.9.6 Python/2.7.6

{
    "1": {
        "tags": [
            "http://localhost:5000/tags/1",
            "http://localhost:5000/tags/2"
        ],
        "task": "Buy rice"
    }
}

Now that we're done with the Todo.get and Todo.put, lets do TodoItem.get:

class TodoItem(rest.Resource):
    def get(self, todo_id):
        """
        Get specific information on a Todo item

        :param todo_id: The Todo Item's ID, which is unique and a primary key
        :type todo_id: int
        """

        try:
            with orm.db_session:
                todo = Todo[todo_id]  # 1
                tags = [{tag.name: tag.url} for tag in todo.tags]  # 2

                return {
                    "task": todo.data,
                    "tags": tags
                }

        except orm.ObjectNotFound:  # 3
            return {}, 404

Since we are getting todo_id from the request itself, we can use it to get the Todo item with that id in 1. This syntax is the same as Todo.get(id=todo_id).

In 2, we are are creating a list of dictionaries from the tags in todo.tags. We are using tag.name and tag.url. If you just wanted to get the names of of the tags, you could do either of these:

tag_names = list(todo.tags.name)

tag_names = [tag.name for tag in todo.tags]

If you think I'm pulling your leg, you can check the source code and run it for yourself. In 3 if we cannot find the object, then we return a 404 error message back.

Now on to Tags.get:

class Tags(rest.Resource):
    def get(self):
        """Will show you all tags"""

        with orm.db_session:
            return {
                tag.name: tag.url
                for tag in Tag.select()
            }

Nothing new here, very similar logic to our / url. Finally in our TagItem.get we have:

class TagItem(rest.Resource):
    def get(self, tag_id):
        """
        Will show you information about a specific tag

        :param tag_id: ID for the tag
        :type tag_id: int
        """

        try:
            with orm.db_session:
                tag = Tag[tag_id]
                todos = list(tag.todos.data)  # 1

                return {
                    "tag": tag.name,
                    "tasks": todos
                }

        except orm.ObjectNotFound:
            return {}, 404

This is similar logic to that of TodoItem.get. The difference here is that in 1, we're getting all the data for the todos in a different way since we only need to know one thing. The code in 1 is the same as:

todos = [tag.data for tag in todo.tags]

Deleting Objects

All that's left is to find a way to delete objects from the database.

def delete(self, todo_id):

    try:
        with orm.db_session:
            todo = Todo[todo_id]  # 1

            if todo:
                tags = todo.tags.copy()  # 2
                todo.delete() # 3

                for tag in tags:
                    if not tag.todos:  # 4
                        tag.delete()  # 5
    except orm.ObjectNotFound:
        return {}, 400

    return {}, 200

In 1 we get the todo item like before. In 2, we copy the tags, because when we delete them in 3, we can no longer reference them through todo.tags, since the todo item is marked for deletion. If you do not do this, then you are going to get a OperationWithDeletedObjectError.

In 4 we check to see if the tag has todo items associated with it, if it doesn't then we delete the tag too in 5.

Now, a demonstration of the API that we've built: