Today, we will not...

• Worry about the app's general appearance
  • CSS, Javascript UI
  • (I'll take care of that)
• Learn basic Python
  • control flow, namespaces, classes
  • (but ask me to clarify anything as we go)

git: Distributed Revision Control

										
$ cd {WORKING_DIR}
$ django-admin.py startproject mysite
										
									

										
$ cd YourFavouriteDirectory
$ git clone eleyine.github.com/pyladies-django-workshop
$ cd pyladies-django-workshop
# rewind to the start of the project
$ git reset --hard boilerplate
										
									

pip: Python Package Manager

										
# Installs package into site-packages
# directory of your 'default' Python lib
$ pip install SomePackage
  [...]
  Successfully installed SomePackage
										
									

virtualenvwrapper: Virtual Environment Manager

										
# in pyladies-django-workshop
$ mkvirtualenv pyladies-django
$ workon pyladies-django
(pyladies-django) $ pip install -r requirements.txt
(pyladies-django) $ pip list
(pyladies-django) $ python
>>> import django
										
									

npm: Node package manager

										
# in pyladies-django-workshop
$ npm install
										
									

bower: Package Manager for the web

										
# in pyladies-django-workshop
$ sudo npm install -g bower
# install packages in manifest file 'bower.json'
$ bower install
$ bower list
										
									

The Zen of Python

							
>>> import this
The Zen of Python, by Tim Peters

Beautiful is better than ugly.
Explicit is better than implicit.
Simple is better than complex.
Complex is better than complicated.
Flat is better than nested.
Sparse is better than dense.
Readability counts.
Special cases aren't special enough to break the rules.
							
						

Django at a Glance

• Rapid development and clean, pragmatic design.
• Focus on automation and Don't Repeat Yourself (DRY)
• Thriving ecosystem
• Object-Relational Mapping (ORM)
• Production ready administrative interface
• Elegant URL scheme

Activating Models

$ python manage.py makemigrations
$ python manage.py migrate
					

Object Relational Mapping (ORM) -> Database Agnostic

Playing with the API

						
(pyladies-django) $ python manage.py shell
>>> from notes.models import Note
>>> Note.objects.all()
[]
>>> n = Note(title='My First Note', content='My first content')
>>> n.save()
>>> n.id
1
>>> n.title
"My First Note"
>>> n.title = "This is not really my first Note"
>>> n.save()
>>> Note.objects.all()
[<Note: Note object>]
						
					

Shell Time

Remember to do your migrations.

						
(pyladies-django) $ python manage.py makemigrations
(pyladies-django) $ python manage.py migrate
					
					

or

(pyladies-django) $ python manage.py flush
(pyladies-django) $ python manage.py migrate

Shell Time

(pyladies-django) $ python manage.py shell
>>> from notes.models import Note, Tag
>>> Note.objects.create(title='My First Note')
<Note: My First Note>
>>> n = Note.objects.get(id=1)
>>> t = Tag.objects.create(keyword='pyladies')
>>> n.tags
<django.db.models.fields.related.ManyRelatedManager object at 0x10be21550>
>>> n.tags.all()
[]
>>> n.tags.add(t)
>>> Note.objects.first().tags.all()
[<Tag: #pyladies>]

Creating an Admin User

(pyladies-django) $ python manage.py createsuperuser

or execute bash script

(pyladies-django) $ git reset --hard solAdmin0
(pyladies-django) $ chmod u+x ./scripts/createsuperuser
(pyladies-django) $ ./scripts/createsuperuser

Writing our First View (cont'd)

Edit pyladies_django_project/urls.py

from django.conf.urls import patterns, include, url
from django.contrib import admin

urlpatterns = patterns('',
    url(r'^notes/', include('notes.urls')),
    url(r'^', include('notes.urls')),
    url(r'^admin/', include(admin.site.urls)),
)
					

Go to http://127.0.0.1:8000/notes/

Go to http://127.0.0.1:8000/

Writing a view that actually does something

Update the index function in notes/views.py

from notes.models import Note
 
def index(request):
    notes = Note.objects.all()
    output = ' / '.join([note.title for note in notes])
    return HttpResponse(output)
					

Yep, templates

What Templates look like

Open templates/base.html

<!DOCTYPE html>
<html>
  <head>
    <title>Not Google Keep</title>
    {% include 'stylesheets.html' %}
  </head>

  <body>
    {% include 'navbar.html' %}

      {% block content %}
        <div class="container main-content">
          <p> There is nothing here yet. Let's start building! </p>
        </div>
      {% endblock %}

    {% include 'javascripts.html' %}
    {% block scripts %}{% endblock %}
  </body>
</html>

					

In templates/notes/index.html (git reset --hard simpleIndex)

{% extends "base.html" %}

{% block content %}
<div class="container main-content {% if search %}search{% endif %}">
    <div class="row">
        <div class="col-lg-12" id="container">
            {% for note in notes %}
              <p>{{ note.title}}</p>
            {% empty %}
              <div class="no-notes-container">
              <div class="no-notes text-center">
                  {% if search %}
                    <h3>No matching notes.</h3>
                  {% else %}
                    <h3>Your {% if archive %}archived{% endif %} notes will appear here.</h3>
                  {% endif %}
              </div>
              </div>
          {% endfor %}
        </div><!-- /#container -->
    </div>
</div><!-- /main content -->
{% endblock %}

					

Writing a view that actually does something (for real)

Update the index function in notes/views.py

from django.template import RequestContext, loader
from notes.models import Note
 
def index(request):
    template = loader.get_template('notes/index.html')
    context = RequestContext(request, {
        'notes': Note.objects.all(),
    })
    return HttpResponse(template.render(context))
					

Let's add a Form Template

Update templates/notes/index.html to include the form (this is a markup-simplified version)

git reset --hard noteForm

<div class="container main-content {% if search %}search{% endif %}">
    <div id="container-wrapper">
        {% if search %}
            <!-- search stuff -->
        {% else %}
            {% include "notes/note-form.html" %}
        {% endif %}

        <div id="container">
            {% for note in notes %}
                {% include "notes/note-container.html" %}
            {% endfor %}
        </div>
    </div> <!-- /#container-wrapper -->
</div><!-- /main content -->

					

Form Template

Edit templates/notes/note-form.html (this is a markup-simplified version)

git reset --hard noteForm

<div class="form-wrapper">
    <form action="{% url 'create_note' %}" method="post">
        {% csrf_token %}
        <fieldset>
        <input name="title" placeholder="Title"/>
        <textarea name="content" placeholder="Add note" ></textarea>
        {% for color in colors %}
                <input type="radio" name="color" value="{{ color.0 }}" 
                {% if forloop.first %} checked {% endif %}/>
        {% endfor %}
        <button type="submit" class="done-button" value="submit">Done</button>
        </fieldset>
    </form>
</div>

					

Ideally, we want tags to be created/updated and saved at the same time as Note content.

Use signals!

Signals allow certain senders [Note] to notify a set of receivers [updateTags] that some action has taken place. They’re especially useful when many pieces of code may be interested in the same events [Note content creation/update].

urlpatterns = patterns('',
    url(r'^(?P<note_id>\d+)/update$', views.NoteAction.as_view(), name='update_note'),
    url(r'^(?P<note_id>\d+)/update/pin$', views.PinnedNoteAction.as_view(), name='update_note_pin'),
    url(r'^(?P<note_id>\d+)/update/archive$', views.ArchiveNoteAction.as_view(), name='update_note_archive'),
)

class ArchiveNoteAction(NoteAction):
    form_class = ArchiveNoteForm

class PinnedNoteAction(NoteAction):
    form_class = PinnedNoteForm

Voila http://localhost:8000/

class SearchIndexView(IndexView):
    index_type = 'search'

    def get_queryset(self):
        print self.kwargs
        if 'tag_keyword' in self.kwargs:
            return Note.objects.filter(
                tags__keyword__icontains=self.kwargs['tag_keyword'])
        else:
            messages.error(request, 'Invalid Search')
            return []

from django.http import JsonResponse

class TagJsonListView(generic.TemplateView):

    def render_to_response(self, context, **response_kwargs):
        keywords = [{'name': t.keyword} for t in Tag.objects.all()]
        return JsonResponse(keywords, safe=False)

We're finally done! http://localhost:8000/