Please enable JavaScript.

Coggle requires JavaScript to display documents.

Django (CONCEPTS (FORUM (Forms can validate data, and have helpful…

- - - - Multi-table (not recommended) :warning:
        Multi-table inheritance create table for each class in the database
      - Abstract :check:
        Abstract inheritance doesn’t create extra tables. In this case we don’t need to query multiple tables to get the result as the case was with multi-table inheritance.
        create a Meta class in Model class and create abstract attr with True
    - - Foreign keys :question:
      - One-One
      - Many-Many:question:
        Django create through table (jump table) automatically
      - Generic Foreign Keys(GFK)-- is not good in terms of performance :forbidden:
    - - Model.objects.select_related().filter()
      - Model.objects.prefetch_related().filter()
  - - - Simple tags
      - Inclusion tags
      - custom tags
  - - - from django.contrib import admin
        admin.register(PetModel)
        class Pet(admin.ModelAdmin):
        list_display = ['name','age' ...]
- - - - urls.py
        
        routing file, uses regex
        
        imports the view function from views.py from app level
        
        we might need to create urls.py manually
      - apps.py is specific to the app
        apps.py for conf and initialization
      - add app to the project by adding an entry to settings.py file
      - views.py
        
        views.py implements the view function
        
        from django.http import HttpResponse
      - static-files
        
        create folder at project level directory: static
        
        in settings.py, create a variable STATICFILES_DIR = [os.path.join(BASE_DIR, 'static'),]
      - templates
        
        default template engine is Jinja
        
        create folders in the app-directory level: templates/<app name>/index.html(or any other html file). <app name> inside the templates folder so that django doesn’t confuse with appname at top level
      - models.py
        
        keep ORM models in this file, create more files if needed
        
        models are imported in views.py and used to interact with DB
        
        after making changes to models.py file create migrations
        python manage.py makemigrations <model name>
        python manage.py migrate # to make the changes
        
        add new models to admin site, register the model:
        from django.contrib import admin
        admin.site.register(<Model from models.py>)
        
        fixing plural name in Admin site for the app
        create Meta class
        class Meta:
        verbose_name_plural = 'name'
    - - manage.py is used to run things like: migrations, dev-server …
      - run-server: "python manage.py runserver"
      - migration: "python manage.py migrate "
      - python manage.py createsuperuser --name=<name of user> --email=<email of user> # this superuser(staff user) can create more users and more things
      - python manage.py startapp <app name> # to create an app using manage.py
      - python manage.py shell # interactive shell
    - - SECRET_KEY which you shouldn’t push to github AT ALL.
      - settings.py -> INSTALLED_APPS, contains all apps for this projects
      - settings.py -> MIDDLEWARE, have authentication modules which is dependent on session layer. Order in MIDDLEWARE is very important
- - - - Model.objects.filter(condition1=<something>, condition2=...)
      - "___" in filter condition have special meaning :question:
    - - DoesnotExists, MultipleObjectsReturne exceptions could be raised :warning:
  - - - Loop: posts is a context which is passed to render function as dict whose key name is 'posts'
        {% block content %}
        {% for post in posts %}<h1> {{ post }} </h1>
        {% endfor %}
        {% endblock %}
      - from django.shortcuts import render
      - Template tag may/maynot take argument to function, e.g pet.objects.all
        pet.submittion_date|date:"M D Y"(here argument is after : followed by ""
      - Loading static files: {% load static %}
        href="{% static 'mystyle.css' %}"
  - - - def view_func(request, <inputfunction>):
        ...
        return render()
    - - from django.views.generic.edit import UpdateView
      - if custom context needed for data, implement get_context_data()
      - most of generic built-in view are create by combining multiple Mixin views
    - - We create normal class extending object and define functions (for some custom code)
        and finally we call super().same_fuction() to pass the call.
        this is based on MRO concept, nothing special