Django Getting Started Notes:

Useful Resources:

Blog-Website-Tutorial

Project Creation Steps:

Create virtual environment:
```
virtualenv venv
```
Activate virtual environment:
```
    source venv/bin/activate
```
Install Django:
```
    pip install django
```
Start new django-project:
```
    dgango-admin startproject BlogHub
```
Change directory to project-directory:
```
    cd BlogHub
```
Run development Server:
```
    python manage.py runserver
```

Create New Application:

Create new application:
```
    python manage.py blog
```

Add the new app to settings.py:

    INSTALLED_APPS = [
    'blog.apps.BlogConfig',
    'django.contrib.admin',
    'django.contrib.auth',
    'django.contrib.contenttypes',
    'django.contrib.sessions',
    'django.contrib.messages',
    'django.contrib.staticfiles',
 ]

View:

In blog/views.py:

   from django.shortcuts import render
   from django.http import HttpResponse

    # Create your views here.
    def home(request):
        return render(request, 'blog/home.html')
        
    def about(request):
       return HttpResponse('<h1>BlogHub About</h1>')

In blog/urls:

    from django.urls import path
    from . import views
    
    
    urlpatterns = [
        path('', views.home, name="blog-home"),
        path('about/', views.about, name="blog-about"),
    ]

``

In BlogHub/urls:

    from django.contrib import admin
    from django.urls import path, include
    
    urlpatterns = [
        path('admin/', admin.site.urls),
        path('', include('blog.urls')),
    ]

To use models in views:

    from .models import Post
    
    def home(request):
        context = {
            'posts': Post.objects.all()
        }
        return render(request, 'blog/home.html', context)

Templates:

Under blog/ create new templates directory.

Under blog/templates/ create new app directory:

    blog --> templates --> blog -> files.html

Models:

Make sure to make at least one migration to be able to use admin-page:

Create Class for each Table in app/models.py:

    from django.db import models
    from django.utils import timezone
    from django.contrib.auth.models import User
    
    
    # Create your models here.
    class Post(models.Model):
        title = models.CharField(max_length=100)
        content = models.TextField()
        date_posted = models.DateTimeField(default=timezone.now)
        author = models.ForeignKey(User, on_delete=models.CASCADE)

Prepare migrations:
```
    python manage.py makemigrations
```
Apply migrations:
```
    python manage.py migrate
```

Django has its own ORM (Object Relational Mapper), it allows to access databases.

If you want to see exact sql query run to create a model:

    python manage.py sqlmigrate blog 0001

    BEGIN;
    --
    -- Create model Post
    --
    CREATE TABLE "blog_post" ("id" integer NOT NULL PRIMARY KEY AUTOINCREMENT, "title" varchar(100) NOT NULL, "content" text NOT NULL, "date_posted" datetime NOT NULL, "author_id" integer NOT NULL REFERENCES "auth_user" ("id") DEFERRABLE INITIALLY DEFERRED);
    CREATE INDEX "blog_post_author_id_dd7a8485" ON "blog_post" ("author_id");
    COMMIT;

Admin-Page:

Database migration must be done before this command:
```
    python manage.p createsueruser
```

To add model to admin-page:

    from django.contrib import admin
    from .models import Post
    admin.site.register(Post)

Shell:

To open python shell for debugging, testing, or investigation:
- This opens our django-project in an ordinary python shell:
```
    python manage.py shell
```
- To open the project with iPython shell (it supports colors and auto-complete):
```
    pip install ipython
```
```
    python manage.py shell
```

Investigating our models:

    In [1]: from blog.models import Post                                           
    In [2]: from django.contrib.auth.models import User                             
    
    In [3]: User.objects.all()                                                     
    Out[3]: <QuerySet [<User: admin>, <User: maha>]>
    
    
    In [4]: User.objects.first()                                                   
    Out[4]: <User: admin>
    
    
    In [5]: User.objects.filter(username='admin')                               
    Out[5]: <QuerySet [<User: admin>]>
    
    
    In [6]: User.objects.filter(username='admin').first()                       
    Out[6]: <User: admin>
    
    
    In [7]: user = User.objects.filter(username='maha').first()
    In [8]: user                                                                   
    Out[8]: <User: maha>
    
    
    In [9]: user.id                                                                
    Out[9]: 2


    In [10]: user.pk                                                               
    Out[10]: 2
    
    
    In [11]: user = User.objects.get(id=1)                                         
    In [12]: user                                                                  
    Out[12]: <User: admin>

Create new object via python shell:

    In [16]: post_1 = Post(title='Blog 1', content='First Post Content!', author=use
        ...: r)                                                                     
    
    In [17]: Post.objects.all()                                                     
    Out[17]: <QuerySet []>
    
    In [18]: post_1.save()                                                         
    
    In [19]: Post.objects.all()                                                     
    Out[19]: <QuerySet [<Post: Post object (1)>]>

To get more descriptive output than this:

    In [19]: Post.objects.all()                                                    
    Out[19]: <QuerySet [<Post: Post object (1)>]>

In models.py:

    class Post(models.Model):
        ... 
        def __str__(self):
            return self.title

Restart the python shell.

The output will be:

    In [3]: Post.objects.all()                     
    Out[3]: <QuerySet [<Post: Blog 1>]>

To get all posts created by a user:

    In [19]: user.post_set.all()                                                   
    Out[19]: <QuerySet [<Post: Blog 2>]>

Creae new post by this user:

    In [20]: user.post_set.create(title='Blog 3', content='Third Post Content!')
    Out[20]: <Post: Blog 3>
    
    In [21]: Post.objects.all()                                                    
    Out[21]: <QuerySet [<Post: Blog 1>, <Post: Blog 2>, <Post: Blog 3>]>

User Registeration:

Create new users app:
```
    python manage.py startapp users
```

Add users to the BlogHub/setting.py --> INSTALLED_APPS:

    INSTALLED_APPS = [
        'users.apps.UsersConfig',
        ...
    ]

Create register view in users/views.py:

    from django.shortcuts import render
    from django.contrib.auth.forms import  UserCreationForm


    def register(request):
        if request.method == 'POST':
            form = UserCreationForm(request.POST)
            if form.is_valid():
                username = form.cleaned_data.get('username')
                messages.success(request, f'Account created for { username }!')
                return redirect('blog-home')
        else:
            form = UserCreationForm()
        return render(request, 'users/register.html', {'form': form})

Create register.html in users/templates/users/:

    {% extends 'blog/base.html' %}
    {% block content %}
            <div class="content-section">
                <form method="POST">
                    {% csrf_token %}
                    <fieldset class="form-group">
                        <legend class="border-bottom mb-4">Join Today</legend>
                        {{ form.as_p }}
                    </fieldset>
                    <div class="form-group">
                        <button class="btn btn-outline-info" type="submit">Sign Up</button>
                    </div>
                </form>
    
                <div class="border-top pt-3">
                    <small class="text-mutted">
                        Already Have An Account? <a class="ml-2" href="#">Sign In</a>
                    </small>
                </div>
            </div>
    {% endblock content %}

Link a url to register view in BlogHub/urls.py:

    ...
    from users import views as users_views
    
    urlpattern = [
        ...
        path('register/', users_views.register, name='register'),
        ...
    ]

Types of messages:

    from django.contrib import messages
    
    messages.debug
    messages.info
    messages.success
    messages.warning
    messages.error

Seach about these topics:

Magic functions (ex: def _str_(self):)
Vertical column filter (ex: post.date_posted|date:"F d, Y" Django Date Filter
CSRF Tokens.
Class Meta

MahaAmin / BlogHub