JavaDevVictoria
diff --git a/‎book.json‎
Lines changed: 1 addition & 1 deletion b/‎book.json‎
Lines changed: 1 addition & 1 deletion
diff --git a/‎en/css/README.md‎
Lines changed: 19 additions & 15 deletions b/‎en/css/README.md‎
Lines changed: 19 additions & 15 deletions
diff --git a/‎en/django_orm/README.md‎
Lines changed: 76 additions & 35 deletions b/‎en/django_orm/README.md‎
Lines changed: 76 additions & 35 deletions
@@ -9,7 +9,7 @@
         "[email protected]",
         "[email protected]",
         "[email protected]",
-        "[email protected].6"
+        "[email protected].7"
     ],
     "pluginsConfig": {
         "ga": {
 
@@ -16,9 +16,9 @@ It was written by programmers who worked for Twitter and is now developed by vol
 
 ## Install Bootstrap
 
-To install Bootstrap, you need to add this to your `<head>` in your `.html` file (`blog/templates/blog/post_list.html`):
+To install Bootstrap, you need to add this to your `<head>` in your `.html` file:
 
-```html
+```html:blog/templates/blog/post_list.html
 <link rel="stylesheet" href="//maxcdn.bootstrapcdn.com/bootstrap/3.2.0/css/bootstrap.min.css">
 <link rel="stylesheet" href="//maxcdn.bootstrapcdn.com/bootstrap/3.2.0/css/bootstrap-theme.min.css">
 ```
@@ -38,15 +38,17 @@ Finally we will take a closer look at these things we've been calling __static f
 
 ### Where to put static files for Django
 
-As you saw when we ran `collectstatic` on the server, Django already knows where to find the static files for the built-in "admin" app. Now we just need to add some static files for our own app, `blog`. 
+As you saw when we ran `collectstatic` on the server, Django already knows where to find the static files for the built-in "admin" app. Now we just need to add some static files for our own app, `blog`.
 
 We do that by creating a folder called `static` inside the blog app:
 
+```
     djangogirls
     ├── blog
     │   ├── migrations
     │   └── static
     └── mysite
+```
 
 Django will automatically find any folders called "static" inside any of your apps' folders, and it will be able to use their contents as static files.
 
@@ -56,11 +58,13 @@ Django will automatically find any folders called "static" inside any of your ap
 
 Let's create a CSS file now, to add your own style to your web-page. Create a new directory called `css` inside your `static` directory. Then create a new file called `blog.css` inside this `css` directory. Ready?
 
+```
     djangogirls
     └─── blog
          └─── static
               └─── css
                    └─── blog.css
+```
 
 Time to write some CSS! Open up the `blog/static/css/blog.css` file in your code editor.
 
@@ -70,7 +74,7 @@ But let's do at least a little. Maybe we could change the color of our header? T
 
 In your `blog/static/css/blog.css` file you should add the following code:
 
-```css
+```css:blog/static/css/blog.css
 h1 a {
     color: #FCA205;
 }
@@ -88,21 +92,21 @@ Read about [CSS Selectors in w3schools](http://www.w3schools.com/cssref/css_sele
 
 Then, we need to also tell our HTML template that we added some CSS. Open the `blog/templates/blog/post_list.html` file and add this line at the very beginning of it:
 
-```html
+```html:blog/templates/blog/post_list.html
 {% load staticfiles %}
 ```
 
 We're just loading static files here :). Then, between the `<head>` and `</head>`, after the links to the Bootstrap CSS files (the browser reads the files in the order they're given, so code in our file may override code in Bootstrap files), add this line:
 
-```html
+```html:blog/templates/blog/post_list.html
 <link rel="stylesheet" href="{% static 'css/blog.css' %}">
 ```
 
 We just told our template where our CSS file is located.
 
 Your file should now look like this:
 
-```html
+```html:blog/templates/blog/post_list.html
 {% load staticfiles %}
 <html>
     <head>
@@ -133,7 +137,7 @@ OK, save the file and refresh the site!
 
 Nice work! Maybe we would also like to give our website a little air and increase the margin on the left side? Let's try this!
 
-```css
+```css:blog/static/css/blog.css
 body {
     padding-left: 15px;
 }
@@ -145,15 +149,15 @@ Add this to your CSS, save the file and see how it works!
 
 Maybe we can customize the font in our header? Paste this into your `<head>` in `blog/templates/blog/post_list.html` file:
 
-```html
+```html:blog/templates/blog/post_list.html
 <link href="http://fonts.googleapis.com/css?family=Lobster&subset=latin,latin-ext" rel="stylesheet" type="text/css">
 ```
 
 This line will import a font called *Lobster* from Google Fonts (https://www.google.com/fonts).
 
 Now add the line `font-family: 'Lobster';` in the CSS file `blog/static/css/blog.css` inside the `h1 a` declaration block (the code between the braces `{` and `}`)  and refresh the page:
 
-```css
+```css:blog/static/css/blog.css
 h1 a {
     color: #FCA205;
     font-family: 'Lobster';
@@ -169,15 +173,15 @@ As mentioned above, CSS has a concept of classes, which basically allows you to
 
 Go ahead and name some parts of the HTML code. Add a class called `page-header` to your `div` that contains your header, like this:
 
-```html
+```html:blog/templates/blog/post_list.html
 <div class="page-header">
     <h1><a href="/">Django Girls Blog</a></h1>
 </div>
 ```
 
 And now add a class `post` to your `div` containing a blog post.
 
-```html
+```html:blog/templates/blog/post_list.html
 <div class="post">
     <p>published: {{ post.published_date }}</p>
     <h1><a href="">{{ post.title }}</a></h1>
@@ -187,7 +191,7 @@ And now add a class `post` to your `div` containing a blog post.
 
 We will now add declaration blocks to different selectors. Selectors starting with `.` relate to classes. There are many great tutorials and explanations about CSS on the Web to help you understand the following code. For now, just copy and paste it into your `blog/static/css/blog.css` file:
 
-```css
+```css:blog/static/css/blog.css
 .page-header {
     background-color: #ff9400;
     margin-top: 0;
@@ -239,7 +243,7 @@ h1, h2, h3, h4 {
 
 Then surround the HTML code which displays the posts with declarations of classes. Replace this:
 
-```html
+```html:blog/templates/blog/post_list.html
 {% for post in posts %}
     <div class="post">
         <p>published: {{ post.published_date }}</p>
@@ -251,7 +255,7 @@ Then surround the HTML code which displays the posts with declarations of classe
 
 in the `blog/templates/blog/post_list.html` with this:
 
-```html
+```html:blog/templates/blog/post_list.html
 <div class="content container">
     <div class="row">
         <div class="col-md-8">
 
@@ -14,12 +14,16 @@ It's easiest to learn by example. Let's try this, shall we?
 
 Open up your local console (not on PythonAnywhere) and type this command:
 
-    (myvenv) ~/djangogirls$ python manage.py shell
+```:command-line
+(myvenv) ~/djangogirls$ python manage.py shell
+```
 
 The effect should be like this:
 
-    (InteractiveConsole)
-    >>>
+```python:command-line
+(InteractiveConsole)
+>>>
+```
 
 You're now in Django's interactive console. It's just like Python prompt but with some additional Django magic :). You can use all the Python commands here too, of course.
 
@@ -28,19 +32,25 @@ You're now in Django's interactive console. It's just like Python prompt but wit
 
 Let's try to display all of our posts first. You can do that with the following command:
 
-    >>> Post.objects.all()
-    Traceback (most recent call last):
-          File "<console>", line 1, in <module>
-    NameError: name 'Post' is not defined
+```python:command-line
+>>> Post.objects.all()
+Traceback (most recent call last):
+      File "<console>", line 1, in <module>
+NameError: name 'Post' is not defined
+```
 
 Oops! An error showed up. It tells us that there is no Post. It's correct -- we forgot to import it first!
 
-    >>> from blog.models import Post
+```python:command-line
+>>> from blog.models import Post
+```
 
 This is simple: we import model `Post` from `blog.models`. Let's try displaying all posts again:
 
-    >>> Post.objects.all()
-    [<Post: my post title>, <Post: another post title>]
+```python:command-line
+>>> Post.objects.all()
+[<Post: my post title>, <Post: another post title>]
+```
 
 It's a list of the posts we created earlier! We created these posts using the Django admin interface. However, now we want to create new posts using Python, so how do we do that?
 
@@ -49,33 +59,45 @@ It's a list of the posts we created earlier! We created these posts using the Dj
 
 This is how you create a new Post object in database:
 
-    >>> Post.objects.create(author=me, title='Sample title', text='Test')
+```python:command-line
+>>> Post.objects.create(author=me, title='Sample title', text='Test')
+```
 
 But we have one missing ingredient here: `me`. We need to pass an instance of `User` model as an author. How to do that?
 
 Let's import User model first:
 
-    >>> from django.contrib.auth.models import User
+```python:command-line
+>>> from django.contrib.auth.models import User
+```
 
 What users do we have in our database? Try this:
 
-    >>> User.objects.all()
-    [<User: ola>]
+```python:command-line
+>>> User.objects.all()
+[<User: ola>]
+```
 
 It's the superuser we created earlier! Let's get an instance of the user now:
 
-    me = User.objects.get(username='ola')
+```python:command-line
+me = User.objects.get(username='ola')
+```
 
 As you can see, we now `get` a `User` with a `username` that equals to 'ola'. Neat! Of course, you have to adjust it to your username.
 
 Now we can finally create our post:
 
-    >>> Post.objects.create(author=me, title='Sample title', text='Test')
+```python:command-line
+>>> Post.objects.create(author=me, title='Sample title', text='Test')
+```
 
 Hurray! Wanna check if it worked?
 
-    >>> Post.objects.all()
-    [<Post: my post title>, <Post: another post title>, <Post: Sample title>]
+```python:command-line
+>>> Post.objects.all()
+[<Post: my post title>, <Post: another post title>, <Post: Sample title>]
+```
 
 There it is, one more post in the list!
 
@@ -89,46 +111,63 @@ You can now have a little fun and add more posts to see how it works. Add 2-3 mo
 
 A big part of QuerySets is an ability to filter them. Let's say, we want to find all posts that are authored by User ola. We will use `filter` instead of `all` in `Post.objects.all()`. In parentheses we will state what condition(s) needs to be met by a blog post to end up in our queryset. In our situation it is `author` that is equal to `me`. The way to write it in Django is: `author=me`. Now our piece of code looks like this:
 
-    >>> Post.objects.filter(author=me)
-    [<Post: Sample title>, <Post: Post number 2>, <Post: My 3rd post!>, <Post: 4th title of post>]
+```python:command-line
+>>> Post.objects.filter(author=me)
+[<Post: Sample title>, <Post: Post number 2>, <Post: My 3rd post!>, <Post: 4th title of post>]
+```
 
 Or maybe we want to see all the posts that contain a word 'title' in the `title` field?
 
-    >>> Post.objects.filter(title__contains='title')
-    [<Post: Sample title>, <Post: 4th title of post>]
+```python:command-line
+>>> Post.objects.filter(title__contains='title')
+[<Post: Sample title>, <Post: 4th title of post>]
+```
 
 > **Note** There are two underscore characters (`_`) between `title` and `contains`. Django's ORM uses this syntax to separate field names ("title") and operations or filters ("contains"). If you only use one underscore, you'll get an error like "FieldError: Cannot resolve keyword title_contains".
 
 You can also get a list of all published posts. We do it by filtering all the posts that have `published_date` set in the past:
-    >>> from django.utils import timezone
-    >>> Post.objects.filter(published_date__lte=timezone.now())
-    []
+
+```python:command-line
+>>> from django.utils import timezone
+>>> Post.objects.filter(published_date__lte=timezone.now())
+[]
+```
 
 Unfortunately, the post we added from the Python console is not published yet. We can change that! First get an instance of a post we want to publish:
 
-    >>> post = Post.objects.get(title="Sample title")
+```python:command-line
+>>> post = Post.objects.get(title="Sample title")
+```
 
 And then publish it with our `publish` method!
 
-    >>> post.publish()
+```python:command-line
+>>> post.publish()
+```
 
 Now try to get list of published posts again (press the up arrow button 3 times and hit `enter`):
 
-    >>> Post.objects.filter(published_date__lte=timezone.now())
-    [<Post: Sample title>]
+```python:command-line
+>>> Post.objects.filter(published_date__lte=timezone.now())
+[<Post: Sample title>]
+```
 
 
 ### Ordering objects
 
 QuerySets also allow you to order the list of objects. Let's try to order them by `created_date` field:
 
-    >>> Post.objects.order_by('created_date')
-    [<Post: Sample title>, <Post: Post number 2>, <Post: My 3rd post!>, <Post: 4th title of post>]
+```python:command-line
+>>> Post.objects.order_by('created_date')
+[<Post: Sample title>, <Post: Post number 2>, <Post: My 3rd post!>, <Post: 4th title of post>]
+```
 
 We can also reverse the ordering by adding `-` at the beginning:
 
-    >>> Post.objects.order_by('-created_date')
-    [<Post: 4th title of post>,  <Post: My 3rd post!>, <Post: Post number 2>, <Post: Sample title>]
+```python:command-line
+>>> Post.objects.order_by('-created_date')
+[<Post: 4th title of post>,  <Post: My 3rd post!>, <Post: Post number 2>, <Post: Sample title>]
+```
 
 
 ### Chaining QuerySets 
@@ -141,5 +180,7 @@ This is really powerful and lets you write quite complex queries.
 
 Cool! You're now ready for the next part! To close the shell, type this:
 
-    >>> exit()
-    $
+```python:command-line
+>>> exit()
+$
+```