[파이썬] Django란? / 사용법 (커뮤니티 게시판 만들기)

Languages/Python

[파이썬] Django란? / 사용법 (커뮤니티 게시판 만들기)

MOONCO 2021. 3. 3. 00:21

👉 Django란?

파이썬으로 만들어진 무료 웹 프레임워크 ( 웹 사이트 만드는 틀 )

필요성

많은 부분이 이미 만들어져있어서, 쉽고 빠르게 프로젝트를 만들 수 있다.
- 데이터베이스 대화기능, 어드민 패널, 유저 인증 기능 등등

커뮤니티에서 계속 해킹이 이루어지고, 이를 막는 버전이 업데이트 되므로 안전하다.
많은 대기업들이 사용하고 있어서, 신뢰도가 높다.

작동방식

1. 사용자가 서버에 웹페이지를 보내달라고 요청(request)한다.

2. 서버가 메일박스(port)에서 요청이 도착했는지 확인한다
- 장고의 urlresolver가 요청을 가져와 URL과 맞는지 확인한다.
- 만약 일치하는 것이 있으면, 해당 요청을 VIEW에 넘겨준다

3. 요청이 도착했으면, 웹페이지를 보내준다.

👉 설치

pip install django

버전, 설치확인

django-admin --version

프로젝트 만들기

django-admin startproject <프로젝트>

Django 프로젝트 파일의 기능

manage.py ( 명령창을 통해, 각종 장고의 명령을 실행하기 위한 파일 )

<프로젝트> ( 프로젝트명으로 생성된 디렉터리. 함부로 수정 금지! )

  __init__.py ( 파이썬이 이 폴더를 패키지로 인식하게 만들기 )
  
  asgi.py ( 웹서버와, django를 연결해주는 API, wsgi의 상위호환 )
  
  settings.py ( 현재 프로젝트의 기본설정을 덮어쓸 설정들. )
  
  urls.py ( 사용자가 요청하는 URL에 따라, 일치하는 View를 찾아 연결 )
  
  wsgi.py ( 실서비스에서의 웹서비스 진입점? )

Database 만들기 ( 프로젝트 폴더에서 실행 )

# 이미 DB가 존재하면 초기화 된다

python manage.py migrate

슈퍼유저 만들기

python manage.py createsuperuser

슈퍼유저 확인하기

# django 명령창 접속

python manage.py shell

from django.contrib.auth.models import User

superuser = User.objects.filter(is_superuser=True)

superuser # <QuerySet [<User: 이름>]>

슈퍼유저 비밀번호 변경

python manage.py changepassword <이름>

서버 구동하기 ( 8000포트 사용 )

# 실제 사용자의 http 요청 처리가 늦다. ( uwsgi 사용해 해결가능 )
python manage.py runserver 0.0.0.0:8000

You may need to add '0.0.0.0' to ALLOWED_HOSTS 오류 해결

# settings.py 파일에 다음 내용을 추가한다.

# 0.0.0.0 주소를 허용한다는 의미

ALLOWED_HOSTS = ['0.0.0.0']

초기 설정 ( settings.py )

LANGUAGE_CODE = 'ko-kr'

TIME_ZONE = 'Asia/Seoul'


# os 라이브러리 사용하기 위해 가져오기

import os

STATIC_ROOT = os.path.join(BASE_DIR, 'static')

데이터 베이스 설정 ( settings.py )

# 연결된 데이터베이스 정보를 보여준다

# 기본 DB가 sqlite3로 설정되어있다

DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.sqlite3',
        'NAME': BASE_DIR / 'db.sqlite3',
    }
}



# 사용가능한 DB / 변경시 옵션도 지정해 주어야한다

  PostgreSQL : django.db.backends.postgresql
  
  MySQL : django.db.backends.mysql
  
  SQLite3 : django.db.backends.sqlite3
  
  ORACLE : django.db.backends.oracle

앱 만들기

python manage.py startapp <앱>

앱에 설정파일 적용하기 ( settings.py )

# <앱>이 설치되어 있음을, settings.py에게 알려준다

INSTALLED_APPS = [
    '<앱>'
]

👉 Model 이란?

MCV 모델에서 M(Model)의 역할을 담당
DB의 데이터를 생성, 수정한다.
DB에서 가져온 데이터를 View로 전달한다.
Django App 안에 기본적으로 생성되는 models.py 모듈안에 정의
models.py 안에, 여러개의 모델 클래스를 정의하며, 하나 하나가 DB의 테이블에 해당한다

DB에 저장하고 싶은 것 정리하기

게시글 (Post)
    게시자 (author)
    제목 (title)
    내용 (text)
    작성하기 시작한 날짜 (created_date)
    게시판에 올린 날짜 (published_date)

Model 기본 사용법 ( models.py )

# 기본 설정 파일 불러오기 위한 모듈

from django.conf import settings

# DB 불러오기 위한 모듈

from django.db import models

# 현재 시간 불러오기 위한 모듈

from django.utils import timezone



# DB에 생성하고 싶은 테이블을 클래스 형태로 적어준다

# models.Model이 붙어있어야만 장고 모델로 인식한다 

# models.<필드타입>(<필드옵션>) 형식으로 DB를 작성한다

class Post(models.Model):

    # django에서 기본으로 주어지는 AUTH_USER_MODEL(유저 테이블)과 연결한다. / 추후 설명 추가
    
    author = models.ForeignKey(settings.AUTH_USER_MODEL, on_delete=models.CASCADE)
    title = models.CharField(max_length=200)
    text = models.TextField()
    created_date = models.DateTimeField(default=timezone.now())
    published_date = models.DateTimeField(blank=True, null=True)

    # <Post객체>.publish 입력시, 해당 객체의 published_date에 현재시간을 넣어주는 함수
    
    def publish(self):
        self.published_date = timezone.now()
        self.save()

    def __str__(self):
        return self.title
        
        
           
# Primary Key를 지정하지 않아도, Django가 자동지정

# 필드 정의 위해 클래스 변수 사용
( 테이블 컬럼의 메타 데이터를 정의하기 때문에 )

# 구성하고자하는 필드 클래스 객체를 가져온다. 괄호()안에 옵션 지정

# 필드마다 반드시 지정해 주어야 하는 옵션이 존재하기도 한다. (CharField : max_length)

Model 필드 클래스 모음

CharField :

  제한된 문자열 필드
  
  최대 길이(max_length) 옵션을 지정해야 한다.
  
  EmailField : 이메일 주소 체크
  
  GenericIPAddressField : IP 주소 체크
  
  FilePathField : 특정 폴더 경로 체크

  URLField : URL 체크
  
  
TextField : 대용량 문자열 필드


IntegerField :

  32 비트 정수형 필드

  BigIntegerField : 큰 정수 필드
  
  SmallIntegerFiled : 작은 정수 필드
  

BooleanField :

  true / false 필드
  
  NullBooleanField : Null을 허용한 true / false 필드
  
  
DatetimeField :

  날짜, 시간 필드
  
  DateField : 날짜 필드
  
  TimeField : 시간 필드
  
  
DecimalField : 소수점 필드


BinaryField : 바이너리 데이터 필드


FileField : 파일 업로드 필드

  ImageField : 이미지 파일 필드
  
  
UUIDField : GUID(UUID)를 저장하는 필드


# 필드 간 관계 필드

ForeignKey : 외부 테이블에 연결하는 필드

ManyToManyField : 많은 테이블과 많은 테이블 연결하는 필드

OneToOneField : 테이블을 일대일로 연결하는 필드

필드 옵션

# 필드의 인자로 주어, 옵션을 사용할 수 있다.

null :

  null=True 이면, Empty 값을 DB에 NULL로 저장한다.
  
  DB에서 Null이 허용된다.
  
  
blank :

  blank=False 이면, 필수적으로 입력해야 한다.
  
  blank=True 이면, 선택적으로 입력해도 된다.
  
  
primary_key :

  primary_key=True 이면, 해당 필드를 Primary Key로 설정한다
  
  ( 반드시 존재해야하는 Key )
  
  
unique :

  unique=True 이면, 해당 필드를 Unique Key로 설정한다
  
  ( 중복되면 안되는 Key )
  
  
default :

  필드의 기본값을 지정한다. default="WE"
  
  
db_column :

  컬럼명을 기본값이 아닌, 다른 값으로 지정한다. db_column="ME"
  
  
verbose_name :
  
  겉으로 보여줄 필드 이름을 정한다. varbose_name="내용"
  
  
validators :
  
  입력값을 검사할 함수 지정.
  
  필드마다 기본으로 지정되어 있기도함
  
  ( 이메일만 받기, 최대길이, 최소길이, 최대값, 최소값 등등 )
  
  
choices (form widget용) :

  select box 소스로 사용
  
  
help_text(form widget용) :

  필드 입력 도움말
  
  
auto_now_add :

  auto_now_add=True 이면, 레코드 생성시 현재시간으로 자동저장

Model 작성시 주의 사항

blank(공백), null(빈값), default(기본값) 설정은
값이 필수적인지, 아닌지 체크하는데 기본요소로 작용하므로 매번 유의해서 설정 해주어야 한다.

Model을 기반으로, DB적용하기 위한 SQL 형식의 자료(마이그레이션) 만들기

# Django 앱 내부에, migrations 폴더 만들고, 테이블 생성을 위한 파일 생성

python manage.py makemigrations

마이그레이션 파일 ( 0001_initial.py )

# Generated by Django 3.1.7 on 2021-03-15 00:29

import datetime
from django.conf import settings
from django.db import migrations, models
import django.db.models.deletion
from django.utils.timezone import utc


class Migration(migrations.Migration):

    dependencies = [
        migrations.swappable_dependency(settings.AUTH_USER_MODEL),
        ('portfolio', '0001_initial'),
    ]

    operations = [
        migrations.CreateModel(
            name='Post',
            fields=[
                ('id', models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
                ('title', models.CharField(max_length=200)),
                ('created_date', models.DateTimeField(default=datetime.datetime(2021, 3, 15, 0, 29, 31, 14223, tzinfo=utc))),
                ('published_date', models.DateTimeField(blank=True, null=True)),
                ('author', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, to=settings.AUTH_USER_MODEL)),
            ],
        ),
    ]

마이그레이션을 기반으로, 실제 DB에 적용하기

# 테이블 스키마를 이용해, 실제 DB에 적용하기 위한 명령 실행

python manage.py migrate

DB 관리 창(shell) 띄우기

python manage.py dbshell

DB 관리 창(shell) 종료

exit()

기존에 사용하는 DB로 모델만들기

DB 설정해주기 ( <프로젝트>/settings.py )

DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.sqlite3',
        'NAME': BASE_DIR / 'db.sqlite3',
    },
    'referencedb1': {
        'ENGINE': 'django.db.backends.sqlite3',
        'NAME': 'test.sqlite3',
    },
}

모델 적용하기 ( ? )

python manage.py migrate    ## default DB 마이그레이션
python manage.py inspectdb    ## default DB 모델로 만들기

python manage.py migrate --database referencedb1   ## reference DB 마이그레이션
python manage.py inspectdb --database referencedb1   ## reference DB 모델로 만들기

쿼리셋이란?

DB로부터 데이터를 읽고, 필터를 걸거나 정렬을 할수 있게 해주는 명령어

쿼리셋 사용하기 ( django에서 지정한 파일에서만 사용가능, <앱>/views.py 등등)

# 모델에서 DB가져오기

from <앱>.models import Post

# django 기본유저DB 가져오기

from django.contrib.auth.models import User

# timezone 불러오기

from django.utils import timezone



# DB내용 전부 출력하기 (Read)

print(Post.objects.all())

# <QuerySet [<Post: <포스팅1>>,<Post: <포스팅2>>]>

print(User.objects.all())

# <QuerySet [<User: <유저1>>,<Post: <유저2>>]>



# DB에 내용 추가하기 (Create)

# User객체 가져와서 변수에 저장하기

me = User.objects.get(username='<유저1>')

# 새로운 Post 추가하기

Post.objects.create(author=me, title='<제목>', text='<내용>')



# DB 내용 필터링해서 출력하기 (Read)

# author=me인 Post만 출력

print(Post.objects.filter(author=me))

# title에 <제목>포함되는 Post만 출력

print(Post.objects.filter(title__contains='<제목>'))

# 게시일(published_date)에 작성한 Post만 출력

print(Post.objects.filter(published_date__lte=timezone.now()))



# DB 객체 가져와서 함수 실행하기

# title에 <제목>포함되는 Post 객체 가져오기

post = Post.objects.get(title='<제목>')

# <Post객체>.publish() 함수 실행 

post.publish()



# created_date 컬럼을 기준으로 정렬해서 변수에 저장

# 오름차순

order_up = Post.objects.order_by('created_date')

# 내림차순

order_dw = Post.objects.order_by('-created_date')



# 쿼리셋 여러개 연결해서 사용하기

query = Post.objects.filter(published_date__lte=timezone.now()).order_by('published_date')

쿼리셋 조건

키워드	설명
__lt / __gt	보다 작다 / 보다 크다
__lte / __gte	같거나 작다 / 같거나 크다
__in	안에 있는 데이터 검색
__year / __month / __day	해당 년, 월, 일 데이터 검색
__isnull ( <필드명>__isnull = True/False	값이 null인 데이터 검색
__contains / __icontains	지정한 문자열을 포함하는 데이터 검색 ( icontains : 대소문자 구별안함)
__startswith / __istartswith	지정한 문자열로 시작하는 데이터 검색 ( istartswith : 대소문자 구별안함)
__endswith / __iendswith	지정한 문자열로 끝나는 데이터 검색 ( iendswith : 대소문자 구별안함)
__range	문자, 숫자, 날짜의 범위 지정 (숫자, 숫자)

👉 Template란?

MCV 모델에서 V(View)의 역할을 담당
View에서 데이터를 전달받아 화면에 표출한다
'<앱>/templates' 폴더안의 내용을 감지한다

Template 기본 사용법 ( <앱>/templates/<이름>.html )

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Document</title>
</head>
<body>

    {# 주석 : {#주석#} 형식으로, 주석을 넣는다. #}

    {# 템플릿 변수 : {{변수}} 형식으로, views.py에서 인자를 받아온다 #}
    
    <h1>THis is index1, {{message}}</h1>
    
    {# 템플릿 태그 : {%명령%} 형식으로, python 명령을 실행한다 ( if, for 등등 ) #}
    
    {% if count > 0 %}
        Data Conunt = {{ count }}
    {% else %}
        No Data
        
    {# 템플릿 필터 : {{변수|포맷}} 형식으로, 오늘날짜를 넣거나, 대소문자 변환을 하는 등 여러 작업가능 #}
    
    {{ createDate|date:"Y-m-d" }}
    {{ lastNam|lower }}
    
    {# HTML Escape :  <, >, ', ", & 등과 같은 문자들이 있을 경우 이를 HTML요소로 변환해줌 #}
    
    {% autoescape on %}
        {{ content }}            {# content 변수에  <, >, ', "가 들어있다고 가정 #}
    {% endautoescape %}
    {{ content|excape }}
    
    {# HTML 인코딩 변환도구를 이용해, 변수를 미리 html 요소로 바꾸어 전달하는 법도 있다 #}
    
</body>
</html>

👉 View란?

MCV 모델에서 C(Controller)의 역할을 담당
Model에서 데이터를 가져와서, 적절하게 정리한다.
정리한 데이터를 Template에게 전달한다.
각 함수가 하나의 View를 정의한다.
HTTP 요청(Request)을 입력받고, HTTP 응답(Response)를 돌려준다.

URL로 화면 조절하기 ( <프로젝트>/urls.py )

# django 기본화면 불러오는 모듈

from django.contrib import admin



# 경로 설정을 위한 path 함수 불러오기

from django.urls import path



# 만든 앱에서 화면(views.py) 불러오기

from <앱> import views



# url뒤에 ''(공백)찾고, views.py안에 post_list실행

# ex) localhost:8000/   =>    views.post_list()

urlpatterns = [
    path('admin/', admin.site.urls),
    path('', views.post_list, name='post_list'),
]

View에서 실행할 함수 만들고, Template로 정보 전달하기 ( <앱>/views.py )

from django.shortcuts import render

# render(request, <템플릿>, <전달데이터>) 형식으로 사용

def post_list(request):

    # 쿼리셋 이용해 Post를 불러온다 (published_date가 현재시간보다 작거나 같은 Post, 시간기준 오름차순 정렬)

    posts = Post.objects.filter(published_date__lte=timezone.now()).order_by('published_date')

    # <앱>/templates/post_list.html 파일에, 'posts'란 이름으로 posts 전달
      
    return render(request, '<앱>/post_list.html', {'posts':posts})

Template(출력할 웹페이지) 만들기 ( <앱>/templates/post_list.html )

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Document</title>
</head>
<body>
    {# for문 시작 #}
    {% for post in posts %}
    
        <div class="post">
        
            {# 게시일 가져와서 출력 #}
            <p>published: {{post.published_date}}</p>
            
            {# 제목 가져와서 링크만들기 #}
            <h1><a href="">{{post.title}}</a></h1>
            
            {# linebreaksbr : 행바뀜(Enter)를 문단으로 바꾸기 #}
            <p>{{post.text|linebreaksbr}}</p>

        </div>
        
    {# for문 종료 #}
    {% endfor %}
</body>
</html>

👉 Template 재활용

재활용할 수 있게 Template 설정하기 ( <앱>/templates/base.html )

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Document</title>
</head>
<body>
    {% block content %}
    {% endblock %}
</body>
</html>

재사용하기 ( <앱>/templates/post_list.html )

{% extends '<앱>/base.html' %}
{% block content %}
    {% for post in posts %}
        <div class="post">
            <p>published: {{post.published_date}}</p>
            <h1><a href="">{{post.title}}</a></h1>
            <p>{{post.text|linebreaksbr}}</p>
        </div>
    {% endfor %}
{% endblock %

실제 출력 결과 ( <앱>/templates/post_list.html )

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Document</title>
</head>
<body>
    {% for post in posts %}
        <div class="post">
            <p>published: {{post.published_date}}</p>
            <h1><a href="">{{post.title}}</a></h1>
            <p>{{post.text|linebreaksbr}}</p>
        </div>
    {% endfor %}
</body>
</html>

👉 CSS, JS 파일 적용

static 폴더를 만들고, css/js 파일 넣어준다 ( <앱>/static/style.css )

지금까지 django 전체 폴더 구조

<프로젝트>
<앱>
    templates
        base.html
        ...
    static
        style.css
        ...

CSS 스타일 적용하기 ( <앱>/templates/base.html )

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Document</title>
    
    # <앱>/templates/style.css 가져오기
    
    <link rel="stylesheet" href="{% static 'style.css' %}">
    
</head>
<body>
    {% block content %}
    {% endblock %}
</body>
</html>

👉 간단하게 예쁜 스타일 적용하기, 아이콘 사용하기

bootstrap을 사용해준다. ( <앱>/templates/base.html )

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Document</title>
    <link rel="stylesheet" href="{% static 'style.css' %}">
    
    {# bootstrap 스타일, 아이콘 가져오기 #}
    
    <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">
    
</head>
<body>
    {# 페이지 상단에 하트 아이콘 넣기 #}
    
    <span class='glyphicon glyhicon-heart'></span>
    
    {% block content %}
    {% endblock %}
</body>
</html>

* 사용가능한 아이콘 보기 / bootstrapk.com/components/

👉 URL에 따라, 게시글 상세페이지 보여주기

URL에서 인자 받아서 Views로 전달하기 ( <프로젝트>/urls.py )

from django.urls import path
from . import views

urlpatterns = [

    path('admin/', admin.site.urls),
    path('', views.post_list, name='post_list'),
    
    # "localhost/post/<숫자>/" 형태의 주소를 인식한다.
    
    # 주소에서 pk값받아서, "views.post_detail" 으로 전달 (post_detail 함수 만들기)
    
    path('post/<int:pk>/', views.post_detail, name='post_detail'),
    
    
]

Views에 URL인자 받아와서 Template로 전달하기 ( <앱>/views.py )

from django.shortcuts import render, get_object_or_404
from django.utils import timezone
from django.contrib.auth.models import User
from .models import Post


def post_list(request):    
    posts = Post.objects.filter(published_date__lte=timezone.now()).order_by('published_date')
    return render(request, '<앱>/post_list.html', {'posts':posts})
  
  

# 주소에서 받아온 pk인자에 맞는 게시글 불러오기 
  
def post_detail(request, pk):

    # get_object_or_404 : Primary Key가 pk인 게시글 존재 여부 확인, 존재하면 게시글 출력, 존재하지 않으면 특별페이지(404) 출력

    post = get_object_or_404(Post, pk=pk)
    
    # 템플릿(post_detail.html 만들기)으로 post 변수전달
    
    return render(request, '<앱>/post_detail.html', {'post':post})

Template에서 View에서 보낸 데이터 사용해, 상세페이지 만들기 ( <앱>/templates/post_detail.html )

{% extends '<앱>/base.html' %}
{% block content %}
    <div class="post">
        {% if post.published_date %}
            <div class="date">
                {{post.published_date}}
            </div>
        {% endif %}
        <h1>{{post.title}}</h1>
        <p>{{post.text|linebreaksbr}}</p>
    </div>
{% endblock %}

게시글 제목 누르면, 상세페이지로 이동하도록 만들기 ( <앱>/templates/post_list.html )

{% extends '<앱>/base.html' %}
{% block content %}
    {% for post in posts %}
        <div class="post">
            <p>published: {{post.published_date}}</p>
            
            {# 클릭시 post_detail.html 파일로 post.pk값 보내기 #}
            <h1><a href="{% url 'post_detail' pk=post.pk %}">{{post.title}}</a></h1>
            
            <p>{{post.text|linebreaksbr}}</p>
        </div>
    {% endfor %}
{% endblock %}

👉 게시글 작성, 수정 페이지 만들기

View와 DB 연결하는 폼 만들기 ( <앱>/forms.py )

# 폼을 불러오기

from django import forms

# Post 모델 불러오기

from .models import Post


# PostForm 폼 만들기

# forms.ModelForm이 있어야 장고가 폼으로 인식한다.

class PostForm(forms.ModelForm):

    # 폼을 만들때 쓰이는 모델 지정
    
    class Meta:
    
        # Post 모델과 연결하기
        
        model = Post
        
        # 폼에 Post.title, Post.text 불러오기
        
        fields = ('title', 'text',) 
        
        # 화면에 보여줄 필드이름 지정하기
        
        labels = {
            'title':'제목',
            'text':'내용'
        }

URL에 따른 View 설정해주기 ( <프로젝트>/urls.py )

from django.urls import path
from . import views

urlpatterns = [

    path('admin/', admin.site.urls),
    path('', views.post_list, name='post_list'),    
    path('post/<int:pk>/', views.post_detail, name='post_detail'),
    
    # 게시글을 작성할 view(post_new)를 만들어 연결한다.
    
    path('post/new/', views.post_new, name='post_new'),
    
    # 게시글을 수정할 view(post_edit)를 만들어 연결한다.
    
    path('post/<int:pk>/edit/', views.post_view, name='post_edit'),
]

Views에 URL인자 받아와서 Template로 전달하기 ( <앱>/views.py )

# 페이지를 이동시켜주는 모듈

from django.shortcuts import render, get_object_or_404, redirect
from django.utils import timezone

from django.contrib.auth.models import User
from .models import Post

# PostForm 가져오기
from .forms import PostForm


def post_list(request):    
    posts = Post.objects.filter(published_date__lte=timezone.now()).order_by('published_date')
    return render(request, '<앱>/post_list.html', {'posts':posts})
  
  
  
def post_detail(request, pk):
    post = get_object_or_404(Post, pk=pk)
    return render(request, '<앱>/post_detail.html', {'post':post})
    
    
    
# post_new 함수 만들기    
    
def post_new(request):

    # POST 요청이 있다면, 가져오기

    if request.method == "POST":
    
        # POST 요청이 유효한지 확인하기
    
        if form.is_valid():
        
            # post에 가져온 form(제목,텍스트) 저장하기 (아직 DB반영 안함)
        
            post = form.save(commit=False)
            
            # post에 작성자 추가하기
                        
            post.author = request.user
            
            # post에 게시일 추가하기
            
            post.published_date = timezone.now()
            
            # post DB에 적용하기
            
            post.save()
            
            # 방금 작성한 Primary Key와 일치하는 게시글의 상세페이지로 이동한다.
            
            return redirect('post_detail', pk=post.pk)
    
    # POST 요청이 없다면
    
    else:
    
        # 비어있는 폼을 전달해준다. (없으면 에러)
        
        form = PostForm()
        
    # 게시글을 작성하는 페이지(post_edit.html)에 폼을 전달하고 이동한다
    
    return render(request, '<앱>/post_edit.html', {'form':form})
    
    
    
# post_edit 함수 만들기    
    
def post_edit(request, pk):

    # 기존의 게시글 정보 가져오기
    
    post = get_object_or_404(Post, pk=pk)

    if request.method == "POST":
    
        # 수정된 게시글 정보 폼에 넣어서 받아오기 기존(instance) + 수정(request)
        
        form = PostForm(request.POST, instance=post)
        
        if form.is_valid():       
            post = form.save(commit=False)
            post.author = request.user
            post.published_date = timezone.now()    
            post.save()           
            return redirect('post_detail', pk=post.pk)
    else:
    
        # 기존의 게시글 정보 폼에 넣어서 받아오기
        
        form = PostForm(instance=post)
        
        
    return render(request, '<앱>/post_edit.html', {'form':form})

게시글 작성페이지 만들기 ( <앱>/templates/post_edit.html )

{% extends '<앱>/base.html' %}
{% block content %}
   <h1>New Post</h1>
   <form method="post" class="post-form">
   
       # 보안을 위한 작업
       
       {% csrf_token %}
       
       # 폼에서 모든 정보 가져와 출력
       
       {{form.as_p}}
       
       <button type="submit" class="save btn btn-default">Save</button>
   </form> 
{% endblock %}

상세페이지에 수정버튼 만들기 ( <앱>/templates/post_detail.html )

{% extends '<앱>/base.html' %}
{% block content %}
    <div class="post">
        {% if post.published_date %}
            <div class="date">
                {{post.published_date}}
            </div>
        {% endif %}
        
        {# 수정 버튼, post_edit/post/<pk> 으로 이동 #}
        
        <a href="{% url 'post_edit' pk=post.pk %}" class="btn btn-default"><span class='glyphicon glyphicon-pencil'>수정</span></a>
        
        <h1>{{post.title}}</h1>
        <p>{{post.text|linebreaksbr}}</p>
    </div>
{% endblock %}

👉 가입자만 게시글 작성하도록 권한설정

가입자만 게시글 작성 ( <앱>/templates/base.html )

{% load static %}
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Document</title>
    <link href="https://cdn.jsdelivr.net/npm/bootstrap@5.0.0-beta2/dist/css/bootstrap.min.css" rel="stylesheet" integrity="sha384-BmbxuPwQa2lc/FVzBcNJ7UAyJxM6wuqIj61tLrc4wSX0szH/Ev+nYRRuWlolflfl" crossorigin="anonymous">
    <link rel="stylesheet" href="{% static 'css/style.css' %}">
    <link rel="preconnect" href="https://fonts.gstatic.com">
</head>
<body>
    <body>
        <div class="page-header">
        
            # 유저가 권한이 있으면, 새글 버튼 보이기
            
            {% if user.is_authenticated %}
                <a href="{% url 'post_new' %}" class="top-menu"><span class="glyphicon glyphicon-plus">새글</span></a>
            {% endif %}
                <h1><a href="/">Django Girls Blog</a></h1>
        </div>
        <div class="content container">
            <div class="row">
                <div class="col-md-8">
                {% block content %}
                {% endblock %}
                </div>
            </div>
        </div>
    </body>
</body>
</html>

게시글 수정 권한 설정하기 ( <앱>/templates/post_detail.html )

{% extends 'portfolio/index.html' %}
{% block content %}
    <div class="post">
        {% if post.published_date %}
            <div class="date">
                {{post.published_date}}
            </div>
        {% endif %}
        
        # 유저가 권한이 있으면, 수정 버튼 보이기
        
        {% if user.is_authenticated %}
            <a href="{% url 'post_edit' pk=post.pk %}" class="btn btn-default"><span class='glyphicon glyphicon-pencil'>수정</span></a>
        {% endif %}
            <h1>{{post.title}}</h1>
        <p>{{post.text|linebreaksbr}}</p>
    </div>
{% endblock %}

👉 임시저장한 글 (draft) 관리하기

draft 관리페이지로 이동할 url 만들기 ( <앱>/urls.py )

from django.urls import path
from . import views

urlpatterns = [
    path('', views.post_list, name='post_list'),
    path('post/<int:pk>/', views.post_detail, name='post_detail'),
    path('post/new/', views.post_new, name='post_new'),
    path('post/<int:pk>/edit/', views.post_edit, name='post_edit'),
    
    # drafts/ 형식의 url이 감지되면, views.post_draft_list 실행
    
    path('drafts/', views.post_draft_list, name='post_draft_list'),
]

임시저장 게시글 불러와, Template에 전달 ( <앱>/views.py )

from django.shortcuts import render, get_object_or_404, redirect
from django.utils import timezone

from django.contrib.auth.models import User
from .models import Post
from .forms import PostForm

# 중간 생략

def post_draft_list(request):

    # 게시일자가 입력되지 않은 게시글 정보 불러오기
    
    posts = Post.objects.filter(published_date__isnull=True).order_by('created_date')
    
    # 임시저장 페이지로 이동, 정보 전달
    
    return render(request, '<앱>/post_draft_list.html', {'posts':posts})

임시게시판 페이지 만들기 ( <앱>/templates/post_draft_list.html )

{% extends 'portfolio/index.html' %}
{% block content %}
    {% for post in posts %}
        <div class="post">
        
            # 게시글 생성일자 일-달-연 형식으로 표시하기
            
            <p class="date">created: {{post.created_date|date:'d-m-Y'}}</p>
            
            <h1><a href="{% url 'post_detail' pk=post.pk %}">{{post.title}}</a></h1>
            
            # 200 글자가 넘으면 자르기
            
            <p>{{post.text|truncatechars:200}}</p>
            
        </div>
    {% endfor %}
{% endblock %}

임시게시판 이동 버튼 추가하기 ( <앱>/templates/base.html )

{% load static %}
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Document</title>
    <link href="https://cdn.jsdelivr.net/npm/bootstrap@5.0.0-beta2/dist/css/bootstrap.min.css" rel="stylesheet" integrity="sha384-BmbxuPwQa2lc/FVzBcNJ7UAyJxM6wuqIj61tLrc4wSX0szH/Ev+nYRRuWlolflfl" crossorigin="anonymous">
    <link rel="stylesheet" href="{% static 'css/style.css' %}">
    <link rel="preconnect" href="https://fonts.gstatic.com">
</head>
<body>
    <body>
        <div class="page-header">
            {% if user.is_authenticated %}
                <a href="{% url 'post_new' %}" class="top-menu"><span class="glyphicon glyphicon-plus">새글</span></a>
                
                {# 유저가 권한이 있으면, 임시게시판 버튼 보이기 #}
                
                <a href="{% url 'post_draft_list' %}" class="top-menu"><span class="glyphicon glyphicon-edit"></span></a>
            {% else %}
                <a href="{% url 'login' %}" class="top-menu"><span class="glyphicon glyphicon-lock"></span></a> 
            
            {% endif %}
                <h1><a href="/">Django Girls Blog</a></h1>
        </div>
        <div class="content container">
            <div class="row">
                <div class="col-md-8">
                {% block content %}
                {% endblock %}
                </div>
            </div>
        </div>
    </body>
</body>
</html>

👉 임시저장한 글 게시하기 (publish)

url로 게시할 글(임시저장) 정보전달하기 ( <앱>/urls.py )

from django.urls import path
from . import views

urlpatterns = [
    path('', views.post_list, name='post_list'),
    path('post/<int:pk>/', views.post_detail, name='post_detail'),
    path('post/new/', views.post_new, name='post_new'),
    path('post/<int:pk>/edit/', views.post_edit, name='post_edit'),
    path('drafts/', views.post_draft_list, name='post_draft_list'),  
    
    # post/<숫자>/publish/ 형식의 url이 감지되면, views.post_publish 실행
    
    path('post/<int:pk>/publish/', views.post_publish, name='post_publish'),
]

임시저장글 게시하기 ( <앱>/views.py )

from django.shortcuts import render, get_object_or_404, redirect
from django.utils import timezone

from django.contrib.auth.models import User
from .models import Post
from .forms import PostForm

# 중간 생략

def post_publish(request, pk):

    # Primary Key 이용해서, 게시할 글 정보 가져오기
    
    post = get_object_or_404(Post, pk=pk)
    
    # Post 모델 내부에 있는 publish() 함수 사용해서, 게시하기
    
    post.publish()
    
    # 해당 게시글로 이동
    
    return redirect('post_detail', pk=pk)

게시하기 버튼 만들기 ( <앱>/templates/post_detail.html )

{% extends '<앱>/base.html' %}
{% block content %}
    <div class="post">
        {% if post.published_date %}
            <div class="date">
                {{post.published_date}}
            </div>
        
        {# 임시저장한 글 일때, '게시'버튼 출력하고 post_publish에 pk값 전달 #}
            
        {% else %}
            <a href="{% url 'post_publish' pk=post.pk %}" class="btn btn-default"><span class='glyphicon glyphicon-pencil'>게시</span></a>
        
        {% endif %}
        {% if user.is_authenticated %}
            <a href="{% url 'post_edit' pk=post.pk %}" class="btn btn-default"><span class='glyphicon glyphicon-pencil'>수정</span></a>
        {% endif %}
            <h1>{{post.title}}</h1>
        <p>{{post.text|linebreaksbr}}</p>
    </div>
{% endblock %}

👉 게시글 삭제하기 (delete)

url로 삭제할 글 정보전달하기 ( <앱>/urls.py )

from django.urls import path
from . import views

urlpatterns = [
    path('', views.post_list, name='post_list'),
    path('post/<int:pk>/', views.post_detail, name='post_detail'),
    path('post/new/', views.post_new, name='post_new'),
    path('post/<int:pk>/edit/', views.post_edit, name='post_edit'),
    path('drafts/', views.post_draft_list, name='post_draft_list'),      
    path('post/<int:pk>/edit/', views.post_publish, name='post_publish'),
    
    # post/<숫자>/remove/ 형식의 url이 감지되면, views.post_remove 실행
        
    path('post/<int:pk>/remove/', views.post_remove, name='post_remove'),
]

임시저장글 게시하기 ( <앱>/views.py )

from django.shortcuts import render, get_object_or_404, redirect
from django.utils import timezone

from django.contrib.auth.models import User
from .models import Post
from .forms import PostForm

# 중간 생략

def post_publish(request, pk):

    # Primary Key 이용해서, 게시할 글 정보 가져오기
    
    post = get_object_or_404(Post, pk=pk)
    
    # Post 모델 내부에 있는 publish() 함수 사용해서, 게시하기
    
    post.publish()
    
    # 해당 게시글로 이동
    
    return redirect('post_detail', pk=pk)

게시하기 버튼 만들기 ( <앱>/templates/post_detail.html )

{% extends '<앱>/base.html' %}
{% block content %}
    <div class="post">
        {% if post.published_date %}
            <div class="date">
                {{post.published_date}}
            </div>
        
        {# 임시저장한 글 일때, '게시'버튼 출력하고 name='post_publish'에 pk값 전달 #}
            
        {% else %}
            <a href="{% url 'post_publish' pk=post.pk %}" class="btn btn-default"><span class='glyphicon glyphicon-pencil'>게시</span></a>
        
        {% endif %}
        {% if user.is_authenticated %}
            <a href="{% url 'post_edit' pk=post.pk %}" class="btn btn-default"><span class='glyphicon glyphicon-pencil'>수정</span></a>
        {% endif %}
            <h1>{{post.title}}</h1>
        <p>{{post.text|linebreaksbr}}</p>
    </div>
{% endblock %}

👉 로그인 화면 만들기

로그인 화면 보여줄 url 만들기 ( <앱>/urls.py )

# 로그인 화면을 만들 django 기본 모듈 불러오기

from django.contrib.auth import views as auth_views
from django.urls import path
from . import views

urlpatterns = [
    path('', views.post_list, name='post_list'),
    path('post/<int:pk>/', views.post_detail, name='post_detail'),
    path('post/new/', views.post_new, name='post_new'),
    path('post/<int:pk>/edit/', views.post_edit, name='post_edit'),
    path('drafts/', views.post_draft_list, name='post_draft_list'),      
    path('post/<int:pk>/edit/', views.post_publish, name='post_publish'),
    path('post/<int:pk>/remove/', views.post_remove, name='post_remove'),
    
    # accounts/login/ 형식의 url이 감지되면, auth_views.LoginView.as_view() 실행
        
    path('accounts/login/', auth_views.LoginView.as_view(), name='login'),
]

로그인 화면 만들기 ( <앱>/templates/registration/login.html )

{% extends '<앱>/base.html' %}
{% block content %}

    {# 에러 발생시 메시지 출력 #}
    {% if form.errors %}
        <p>이름과 비밀번호가 일치하지 않습니다. 다시 시도해주세요.</p>
        
    {# 에러 발생 안하면, 사용자 정보를 받아, name='login'인 곳으로 전달한다. #}
    {% endif %}
        <form method="post" action="{% url 'login' %}">
            {% csrf_token %}
            <table>
                <tr>
                    <td>{{form.username.lagel_tag}}</td>
                    <td>{{form.username}}</td>
                </tr>
                <tr>
                    <td>{{form.password.lagel_tag}}</td>
                    <td>{{form.password}}</td>
                </tr>
            </table>
            <input type="submit" value="login">
            <input type="hidden" name="next" value="{{next}}">
        </form> 
{% endblock %}

로그인 성공시 이동할 화면 설정하기 ( <프로젝트>/settings.py )

LOGIN_REDIRECT_URL = '/'

로그인 버튼 추가하기 ( <앱>/templates/base.html )

# 헤더 생략

<body>
    <body>
        <div class="page-header">
        
            {# 유저가 로그인했으면, 작성/수정 버튼 보이기 #}
            
            {% if user.is_authenticated %}
                <a href="{% url 'post_new' %}" class="top-menu"><span class="glyphicon glyphicon-plus">새글</span></a>
                <a href="{% url 'post_draft_list' %}" class="top-menu"><span class="glyphicon glyphicon-edit"></span></a>
                
                {# 유저에게 인사메시지 #}
                <p class="top-menu">Hello {{user.username}} </p>
                
            {# 유저가 권한이 없으면, 로그인 버튼 보이기 #}
            
            {% else %}
                <a href="{% url 'login' %}" class="top-menu"><span class="glyphicon glyphicon-lock"></span></a> 
            
            {% endif %}
                <h1><a href="/">Django Girls Blog</a></h1>
        </div>
        <div class="content container">
            <div class="row">
                <div class="col-md-8">
                {% block content %}
                {% endblock %}
                </div>
            </div>
        </div>
    </body>
</body>

👉 로그아웃 화면 만들기

로그아웃 화면 보여줄 url 만들기 ( <앱>/urls.py )

from django.contrib.auth import views as auth_views
from django.urls import path
from . import views

urlpatterns = [
    path('', views.post_list, name='post_list'),
    path('post/<int:pk>/', views.post_detail, name='post_detail'),
    path('post/new/', views.post_new, name='post_new'),
    path('post/<int:pk>/edit/', views.post_edit, name='post_edit'),
    path('drafts/', views.post_draft_list, name='post_draft_list'),      
    path('post/<int:pk>/edit/', views.post_publish, name='post_publish'),
    path('post/<int:pk>/remove/', views.post_remove, name='post_remove'),
    path('accounts/login/', auth_views.LoginView.as_view(), name='login'),
    
    # accounts/logout/ 형식의 url이 감지되면, auth_views.LoginView.as_view() 실행하고, '/' 경로로 이동
        
    path('accounts/logout/', auth_views.LogoutnView.as_view(next_page='/'), name='logout'),
]

로그아웃 버튼 추가하기 ( <앱>/templates/base.html )

# 헤더 생략

<body>
    <body>
        <div class="page-header">
            {% if user.is_authenticated %}
                <a href="{% url 'post_new' %}" class="top-menu"><span class="glyphicon glyphicon-plus">새글</span></a>
                <a href="{% url 'post_draft_list' %}" class="top-menu"><span class="glyphicon glyphicon-edit"></span></a>
                
                {# logout 화면으로 이동 #}
                <p class="top-menu">Hello {{user.username}} <small><a href="{% url 'logout' %}>Log out</a></small></p>
            {% else %}
                <a href="{% url 'login' %}" class="top-menu"><span class="glyphicon glyphicon-lock"></span></a> 
            
            {% endif %}
                <h1><a href="/">Django Girls Blog</a></h1>
        </div>
        <div class="content container">
            <div class="row">
                <div class="col-md-8">
                {% block content %}
                {% endblock %}
                </div>
            </div>
        </div>
    </body>
</body>

👉 댓글 기능 만들기

댓글 저장할 DB 만들기 ( <앱>/models.py )

class Comment(models.Model):

    # Post와 연결
    
    post = models.ForeignKey('<앱>.Post', on_delete=models.CASCADE, related_name='comments')
    author = models.CharField(max_length=200)
    text = models.TextField()
    created_date = models.DateTimeField(default=timezone.now)
    
    # 
    
    approved_comment = models.BooleanField(default=False)

    # 
    
    def approve(self):
        self.approved_comment = True
        self.save()

    # 코멘트 내용 돌려주기
    
    def __str__(self):
        return self.text

마이그레이션 파일 만들고, DB에 적용하기

python manage.py makemigrations <앱>

python manage.py migrate

댓글 생성 화면 보여줄 url 만들기 ( <앱>/urls.py )

from django.contrib.auth import views as auth_views
from django.urls import path
from . import views

urlpatterns = [
    path('', views.post_list, name='post_list'),
    ...
    
    # 중간생략
    
    # post/pk/comment/ 형식의 url이 감지되면, views.add_comment_to_post() 실행
        
    path('post/<int:pk>/comment/', views.add_comment_to_post, name='add_comment_to_post'),
]

댓글생성, DB 연결할 폼 만들기 ( <앱>/forms.py )

form django import forms

# 댓글 모델 불러오기

from models import Post, Comment

class PostForm(forms.ModelForm:
    ...생략

# 댓글 폼 추가

class CommentForm(forms.ModelForm):
    class Meta:
    
        # Post 모델 사용
        
        model = Post
        
        # 연결할 필드 지정
        
        fields = ('title', 'text',)

댓글 기능 만들기 ( <앱>/views.py )

from django.shortcuts import render, get_object_or_404, redirect
from django.utils import timezone

from django.contrib.auth.models import User
from .models import Post

# 댓글 폼 불러오기

from .forms import PostForm, Comment

# 중간 생략

def add_comment_to_post(request, pk):

    # Primary Key 이용해서, 댓글달 글 정보 가져오기
    
    post = get_object_or_404(Post, pk=pk)
    
    # post요청이 있을 때, 댓글 입력받아 폼으로 전달
    
    if request.method=="POST":
        form = CommentForm(request.POST)
        if form.is_valid():
            comment = form.save(commit=False)
            comment.post = post
            comment.save()
            
            # 댓글 작성후, 해당 게시글로 이동
            
            return redirect('post_detail', pk=pk)
            
    # post요청이 없을 때, 댓글 입력 받을 폼을 전달
    
    else:           
        form = CommentForm()
    return render(request, '<앱>/add_comment_to_post.html', {'form':form})

게시글에 댓글 표시하기 ( <앱>/post_detail.html )

    # 포스트 아래에 댓글 추가
    
    {% for comment in post.comments.all %}
        <div class="comment">
            <div class="date">{{comment.created_date}}</div>
            <strong>{{comment.author}}</strong>
            <p>{{comment.text|linebreaks}}</p>
        </div>
        
    # 댓글이 없으면 설명 표시
    
    {% empty %}
        <p>No comments here yet :(</p>
    {% endfor %}
    
    # 댓글 입력 버튼 추가, add_comment_to_post로 pk값 전달
    
    <a href="{% url 'add_comment_to_post' pk=post.pk %}" class="btn btn-default">Add comment</a>

👉 장고 관리자란?

django에서 제공하는, DB내용을 CRUD할수있는 기본 페이지(admin)

장고 관리자 사용법 ( <앱>/admin.py )

# admin페이지 사용하기 위한 모듈 불러오기

from django.contrib import admin


# admin에서 관리할 DB 불러오기

from .models import Post,Comment, <DB1>, ...


# DB내용 CRUD 관리하기 

admin.site.register(Post)
admin.site.register(Comment)
admin.site.register(<DB2>)
...

# 따로 따로 사용해주어야 한다. - admin.site.register(Post, Comment, <DB1>) 오류

👉 Template 태그 만들기 ( 원하는 파이썬 기능을 템플릿에서 사용가능! )

원하는 태그 만들기 ( <앱>/templatetags/mytags.py )

# 숫자 더하기 태그 만들기

from django import template

register = template.Library()


# 필터 태그 만들기

@register.filter
def add(num1, num2):
    return num1 + num2
    

# 심플 태그 만들기

@register.simple_tag
def add_simple(num1, num2):
    return num1 + num2

태그 사용가능하도록 설정해주기 ( <프로젝트>/settings.py )

TEMPLATES = [
    {
        'BACKEND': 'django.template.backends.django.DjangoTemplates',
        'DIRS': [],
        'APP_DIRS': True,
        'OPTIONS': {
            'context_processors': [
                'django.template.context_processors.debug',
                'django.template.context_processors.request',
                'django.contrib.auth.context_processors.auth',
                'django.contrib.messages.context_processors.messages',
            ],
            #########################추가한 부분###########################
            'libraries':{
                'mytags': 'portfolio.templatetags.mytags',
            }
            #############################################################
        },
    },
]

만든 태그 사용하기 ( <앱>/templates/<템플릿> )

{% load mytags %}

{% num1|add:num2 %}

{% add_simple num1 num2 %}


{# num1 + num2 를 화면에 표시! #}

with 태그 이용하기

{% load mytags %}

{% with num1|add:num2 as result1 %}
    {% result1|add:num3 %}
{% endwith %}

{# with를 사용해 태그 결과를 저장하고, 활용할 수 있다. #}

저작자표시 동일조건