Ethan.Devlog

플스 포탈 5G 와이파이가 잡히지 않는 문제 해결

Mon, 11 Mar 2024 07:04:27 GMT

1. 증상

플레이스테이션 포탈이 국내 정발되지 않은 현재, 해외 직구를 통해 구매하였으나 5G 와이파이를 스캔하지 못하는 증상이 발생함(연결이 안되는 것이 아닌, 와이파이 목록 자체에 없음)

2. 대처 (실패)

2.1 TP링크 공유기 구매

TP 링크의 AX3000 제품이 좋다는 평을 듣고 구매했으나, 크게 만족하지 못함

2.2 TP링크 와이파이 증폭기 구매

TP 링크의 AC1200 와이파이 증폭기 제품이 좋다는 평을 듣고 구매했으나. 크게 만족하지 못함

2.3 공유기 및 모뎀 초기화

공유기 및 모뎀을 초기화 했으나 해결되지 않음

2.4 플스 포탈 초기화

플스 포탈을 초기화 했으나 해결되지 않음

3. 대처(성공)

많은 방법을 시도했지만 해결되지 않았기에 TP링크의 제품이 아닌 SK브로드밴드의 공유기를 사용하는 것으로 되돌렸고, 이 과정에서 몇 번의 시행 착오를 통해 플스 포탈로 SK브로드밴드의 5G 와이파이를 연결하는 것을 성공함.

따라서 본인이 플스 포탈 또는 닌텐도를 사용하는데 5G 와이파이가 잡히지 않는다면 아래의 방법을 시도해볼 수 있음

3.1 무선 공유기 로그인

사용하고 있는 인터넷의 공유기에 로그인 한다. 통신사마다 방법이 다르기 때문에 구글에 통신사+공유기 설정을 검색한다. SK 제품이라면 아래의 방법을 따른다.

3.1.1 무선 공유기 주소 찾기

시작 > 검색 > cmd 입력 > 명령 프롬프트 실행 > ipconfig 입력 후, 기본 게이트 웨이의 숫자를 복사해 인터넷 주소창에 붙여넣기한 뒤 이동한다.

아래와 같은 화면(또는 비슷한 화면)이 나온다면 성공이다.

3.1.2 무선 공유기 ID 및 비밀번호

아이디와 비밀번호를 입력해야 한다. ID는 admin(소문자)이며 비밀번호는 여섯글자_admin 이며 대소문자를 구분한다. 비밀번호의 여섯글자를 찾기 위해서는 공유기를 직접 확인해야 한다.

옛날에는 모뎀과 공유기가 하나로 통일된 제품이 많았지만 요즘은 모뎀과 공유기를 분리한다고 한다. 구분하는 방법은 안테나의 유무다. 안테나가 있으면 공유기 안테나가 없으면 모뎀이다. 따라서 우리는 안테나가 달린 공유기를 확인해야 한다.

공유기를 둘러보면 유선 MAC 정보가 있을 것이다. 그 중에서 뒤의 여섯글자(.을 제외한)에 _admin을 붙인게 비밀번호다.

유선 MAC 예시 : 1234.AB12.CD34

비밀번호 예시 : 12CD34_admin(대소문자구분)

3.1.3 와이파이 채널 변경

일본은 와이파이 채널을 100 이하로 사용하고, 우리나라는 와이파이 채널을 100 이상으로 사용한다. 우리가 구매한 플스 포탈은 국내 정발되지 않은 일본 제품이기 때문에 우리나라 와이파이 채널을 찾아내지 못한다. 우리는 우리 집의 와이파이 채널을 일본처럼 100 이하의 채널로 변경하면 된다.

ID와 비밀번호 로그인 후 > 기본설정 > WIFI > WIFI 설정 메뉴로 이동한다.

채널을 Auto에서 48로 변경 후 적용 버튼을 클릭한다.

이제 플스 포탈에서 5G 와이파이를 마음 껏 사용하면 된다.

4. 그래도 안된다면?

그건 나도 모른다. 당신도 직접 찾아보고 다른 사람들을 위해 글을 작성하면 된다.

rest_framework 모듈 불러오지 못하는 문제

Wed, 21 Feb 2024 08:19:45 GMT

1. 발생한 문제

drf 를 학습하는 과정에서 rest_framework 모듈을 인식하지 못하는 문제가 발생

2. 접근

2.1 가상환경이 적용되었는지 확인

문제 없이 적용되어 있음

2.2 drf가 잘 설치되어있는지 확인

설치되어 있음

2.3 vscode에서 인터프리터를 현재 가상환경으로 설정했는지 확인

다른 환경으로 선택됨

3. 해결

2.3의 접근을 통해 vscode의 인터프리터를 현재 가상환경으로 변경하니 문제가 해결됨

Django allauth

Thu, 25 Jan 2024 08:39:31 GMT

회원 가입, 로그인 기능 등 유저 기능을 구현하기 위해 가상 프로젝트 our_school_now_is 를 시작한다.

1. contrib.auth와 allauth

본 프로젝트의 유저 기능을 구현하기 위해 유저 모델은 contrib.auth의 models를 사용하고, 나머지 기능은 allauth 패키지를 통해 구현한다.

allauth 는 contrib.auth가 지원하지 않는 이메일 인증, 소셜 로그인 기능을 지원한다.

또한 allauth은 유저기능이 이미 완성되어 있지만 contrib_auth는 필요한 기능을 모두 직접 구현해야 한다.

따라서 유저 모델은 contrib.auth를 통해, 기능은 allauth를 통해 구현한다.

2. 개발환경 설정

개발환경은 프로젝트에 적용된 개발환경을 사용한다. 프로젝트 루트 디렉토리는 Our_school_now_is 이며, 생성한 앱은 our_school 이다.

2.1 앱 등록

생성한 our_school 앱을 프로젝트 구성 디렉토리의 settings.py에 등록한다.

2.2 유저 모델 정의

User 모델 클래스를 생성한다. 모델은 AbstractUser를 상속받는다.

#models.py

from django.db import models
from django.contrib.auth.models import AbstractUser

# Create your models here.
class User(AbstractUser):
    pass

지금 당장은 필드를 추가하지 않기 떄문에 pass를 작성한다.

2.3 유저 모델 등록

프로젝트 구성 디렉토리의 settings.py에서 our_school 앱의 User 모델을 본 프로젝트의 유저 모델로 사용한다는 것을 정의한다.

#settings.py

AUTH_USER_MODEL = 'our_school.User'

유저 모델을 등록해야 allauth 패키지가 해당 모델을 사용할 수 있다.

2.4 마이그레이션

모델이 변경되었으니 makemigrations 과 migrate를 해준다.

2.5 admin 등록

our_school 앱의 admin.py에 User 모델을 등록한다.

#admin.py

from django.contrib import admin
from django.contrib.auth.admin import UserAdmin
from .models import User

# Register your models here.
admin.site.register(User, UserAdmin)

User 모델을 불러오고, User 모델에 대한 관리자 인터페이스를 제공하는 UserAdmin을 불러온다. 이후 User 모델과, UserAdmin 클래스를 등록한다.

슈퍼유저 계정을 생성한 뒤 관리자 페이지로 접속해보면 User 관리자 페이지를 확인할 수 있다.

2.6 allauth 설치

명령어를 통해 allauth 를 설치한다.

pip install django-allauth

이후 settings.py에 아래의 코드를 추가한다.

#settings.py

AUTHENTICATION_BACKENDS = [
    # Needed to login by username in Django admin, regardless of `allauth`
    'django.contrib.auth.backends.ModelBackend',

    # `allauth` specific authentication methods, such as login by email
    'allauth.account.auth_backends.AuthenticationBackend',
]

이후 settings.py 의 INSTALLED_APPS에 다음 항목들을 추가한다. 만약 일치하는 코드가 이미 작성되어 있다면 추가하지 않는다.

#settings.py

INSTALLED_APPS = [
    'django.contrib.sites',
    'allauth',
    'allauth.account',
    'allauth.socialaccount',
]

이후 INSTALLED_APPS 하단에 다음 항목을 추가한다.

#settings.py

SITE_ID = 1

이후 다음 코드를 추가한다.

# settings.py

EMAIL_BACKEND = "django.core.mail.backends.console.EmailBackend"

2.6.1 에러 발생

본인은 아래와 같은 에러가 나타났다.

Watching for file changes with StatReloader
Exception in thread django-main-thread:
Traceback (most recent call last):
  File "/Users/gwon-uihyeon/.pyenv/versions/3.9.4/lib/python3.9/threading.py", line 954, in _bootstrap_inner
    self.run()
  File "/Users/gwon-uihyeon/.pyenv/versions/3.9.4/lib/python3.9/threading.py", line 892, in run
    self._target(*self._args, **self._kwargs)
  File "/Users/gwon-uihyeon/.pyenv/versions/django-envs/lib/python3.9/site-packages/django/utils/autoreload.py", line 64, in wrapper
    fn(*args, **kwargs)
  File "/Users/gwon-uihyeon/.pyenv/versions/django-envs/lib/python3.9/site-packages/django/core/management/commands/runserver.py", line 125, in inner_run
    autoreload.raise_last_exception()
  File "/Users/gwon-uihyeon/.pyenv/versions/django-envs/lib/python3.9/site-packages/django/utils/autoreload.py", line 87, in raise_last_exception
    raise _exception[1]
  File "/Users/gwon-uihyeon/.pyenv/versions/django-envs/lib/python3.9/site-packages/django/core/management/__init__.py", line 394, in execute
    autoreload.check_errors(django.setup)()
  File "/Users/gwon-uihyeon/.pyenv/versions/django-envs/lib/python3.9/site-packages/django/utils/autoreload.py", line 64, in wrapper
    fn(*args, **kwargs)
  File "/Users/gwon-uihyeon/.pyenv/versions/django-envs/lib/python3.9/site-packages/django/__init__.py", line 24, in setup
    apps.populate(settings.INSTALLED_APPS)
  File "/Users/gwon-uihyeon/.pyenv/versions/django-envs/lib/python3.9/site-packages/django/apps/registry.py", line 124, in populate
    app_config.ready()
  File "/Users/gwon-uihyeon/.pyenv/versions/django-envs/lib/python3.9/site-packages/allauth/account/apps.py", line 17, in ready
    raise ImproperlyConfigured(
django.core.exceptions.ImproperlyConfigured: allauth.account.middleware.AccountMiddleware must be added to settings.MIDDLEWARE

구글링을 통해 해결했다. settings.py의 MIDDLEWARE에 아래의 코드를 추가했다.

#settings.py

MIDDLEWARE = [
    'allauth.account.middleware.AccountMiddleware',
]

2.7 url 패턴 작성

프로젝트 구성 디렉토리의 urls.py 파일을 수정한다.

url이 비어있는 경우, allauth.urls를 참조하는 코드를 추가했다.

#urls.py

from django.contrib import admin
from django.urls import path
from django.urls import include

urlpatterns = [
    path('admin/', admin.site.urls),
    path('', include("allauth.urls"))
]

2.8 마이그레이션

에러를 방지하기 위해 다시한 번 makemigrations 와 migrate를 진행한다.

2.9 결과

개발 서버 실행 후 /login 에 접속하면 아래와 같이 로그인, 비밀번호 찾기, 회원가입 페이지를 확인할 수 있다.

allauth를 통해 생성된 것을 확인할 수 있다.

3. 회원가입 후 홈페이지로 이동

회원가입을 진행하면 url 상에서는 /profile로 이동되지만 404에러가 발생되는 것을 알 수 있다.

이번에는 회원가입 후 홈페이지를 리다이렉션 하는 기능을 알아본다.

3.1 구성 디렉토리 urls 변경

프로젝트 구성 디렉토리의 urls.py를 다음과 같이 수정한다.

#urls.py

urlpatterns = [
    path('admin/', admin.site.urls),
    path('', include("our_school.urls")),  #추가
    path('', include("allauth.urls"))
]

이 경우 비어있는 url 접근 시, 상단에 있는 our_school.urls를 먼저 확인한 뒤, 일치하는 url이 없다면 다시 allauth.urls를 확인한다. 만약 그래도 없다면 404 에러를 발생시킨다.

3.2 앱 디렉토리 urls 생성

다음으로 our_school 앱의 urls.py 를 생성한다.

#ulrs.py

from django.urls import path
from . import views

urlpatterns = [
    path('', views.index, name="index"),
]

3.3 index 뷰 생성

index 뷰를 생성한다.

# views.py

from django.shortcuts import render

# Create your views here.

def index(request):
    return render(request, "our_school/index.html")

3.4 템플릿 생성

index.html 템플릿을 생성한다.



홈페이지

3.5 allauth 세팅 변경

현재는 로그인이 성공하면 account/profile로 이동되도록 기본값이 설정되어 있다. allauth의 기본값을 변경하기 위해서는 settings.py의 allauth 세팅을 추가하면 된다.

allauth의 세팅은 너무 다양해서 본 문서를 참고하고, 필요한 기능을 그때 그때 찾아서 사용하면 된다.

우리가 해야할 일은 로그인 성공 시, account/profile이 아닌, index(url name) 로 이동하도록 변경하는 것이다. settings.py에서 설정하는 방법은 아래와 같다.

#settings.py

ACCOUNT_SIGNUP_REDIRECT_URL = "index"
LOGIN_REDIRECT_URL = "index"

이렇게 하면 로그인 시, 또는 회원가입 시 index(url name)으로 이동하는 것으로 변경된다.

4. 유저 정보 표기

현재는 로그인한 유저 정보와, 로그아웃 버튼이 없다. 만들어보자.

4.1 유저 데이터 접근

현재 로그인된 유저의 데이터를 view에서는 request.user로, 템플릿에서는 {{ user }} 로 접근할 수 있다.

.is_authenticated 속성을 사용하면, 현재 유저가 로그인 했는지 아닌지를 판단할 수 있다.

4.2 템플릿 변경

index.html 템플릿을 다음과 같이 변경한다.



홈페이지

{% if user.is_authenticated %}
    반갑습니다 {{ user }} 님
{% else %}
    로그인이 필요합니다.
{% endif %}


    {% if user.is_authenticated %}
        로그아웃
    {% else %}
        로그인
        회원가입
    {% endif %}

살펴보면 if문으로 user가 로그인 한 경우와 그렇지 않은 경우를 구분했다.

또한 로그아웃, 로그인, 회원가입으로 이동하는 태그를 추가했는데, allauth에서 사용하는 url 정보를 확인하려면 allauth 소스코드를 참고하면 된다.

4.3 로그아웃 뎁스 줄이기

현재 페이지는 로그아웃 버튼 클릭 시, 로그아웃 페이지로 이동한다. 로그아웃 버튼 클릭 시 바로 로그아웃되는 기능을 구현하려면 allauth의 세팅을 추가해야 한다.

#settings.py

ACCOUNT_LOGOUT_ON_GET = "True"

5. 세션 ID

우리가 페이지에 로그인 하면 다른 페이지에 다녀와도 로그인 상태가 유지되는 경우가 잦다. 이와 관련하여 세션 개념을 알아본다.

클라이언트에서 로그인하면 서버에서는 세션ID를 생성한다. 세션ID에는 유저와 관련된 정보들이 담겨있다. 이후 서버는 세션ID를 클라이언트에게 쿠키를 통해 전달하는데, 이후 클라이언트의 요청은 서버로부터 생성된 세션ID를 포함하고 있어 서버는 해당 세션ID를 통해 해당 유저가 로그인된 상태임을 판단한다.

로그인 정보 기억하기 기능은 웹 브라우저를 종료해도 세션 쿠키를 유지할 것인지 아닌지를 정하는 기능이다.

allauth에서는 세션 쿠키를 유지할 것인지 아닌지를 설정하는 것 외에도 세션 쿠키의 유효시간을 직접 설정할 수도 있다. 기본값은 2주이며, 설정은 초 단위로 가능하다.

제네릭 뷰 context 기본값

Mon, 22 Jan 2024 07:27:24 GMT

제네릭 뷰에서는 context로 넘겨주는 데이터의 기본값이 있다. 즉, 지정해주지 않아도 자동으로 넘겨주는 데이터가 있으니 코드를 더 단순하게 작성할 수 있다.

1. ListView

ListView에서 기본값이 할당된 데이터를 알아본다.

template_name 기본값은 모델명_list.html 이므로 템플릿 이름이 일치한다면 삭제 가능

context_object_name 기본값은 object_list, 모델명_list 이므로 템플릿에 object_list 또는 모델명_list로 작성되어 있다면 삭제 가능

page_kwarg 기본값은 page 이므로 템플릿에 page로 작성되어 있다면 삭제 가능

1.1 비교

기존에 작성된 코드와 기본값을 이용해 삭제한 변경된 코드를 비교하면 다음과 같다.

#기존
class PostListView(ListView):
    model = Post
    template_name = "posts/post_list.html"  #기본값은 모델명_list.html
    context_object_name = "posts"  #기본값은 object_list, 모델명_list
    ordering = ['-dt_created']
    paginate_by = 9
    page_kwarg = 'page'  #기본값은 page

#변경
class PostListView(ListView):
    model = Post
    ordering = ['-dt_created']
    paginate_by = 9

2. DetailView

DetailView에서 기본값이 할당된 데이터를 알아본다.

template_name 기본값은 모델명_detail.html 이므로 템플릿 이름이 일치한다면 삭제 가능

pk_url_kwarg 기본값은 pk 이므로 url 패턴에서 라면 삭제 가능

context_object_name 기본값은 모델명 이므로 템플릿에 모델명으로 작성되었다면 삭제 가능

2.1 비교

기존에 작성된 코드와 기본값을 이용해 삭제한 변경된 코드를 비교하면 다음과 같다.

#기존
class PostDetailView(DetailView):
    model = Post
    template_name = "posts/post_detail.html"  #기본값은 모델명_detail.html
    pk_url_kwarg = "post_id"  #기본값은 pk
    context_object_name = "post"  #기본값은 모델명

#변경
class PostDetailView(DetailView):
    model = Post

3. CreateView

CreateView에서 기본값이 할당된 데이터를 알아본다.

template_name 기본값은 모델명_form.html이므로 템플릿 이름이 일치한다면 삭제 가능

3.1 비교

기존에 작성된 코드와 기본값을 이용해 삭제한 변경된 코드를 비교하면 다음과 같다.

#기존
class PostCreateView(CreateView):
    model = Post
    form_class = PostForm
    template_name = "posts/post_form.html"  #기본값은 모델명_form.html

    def get_success_url(self):
        return reverse("post-detail", kwargs={'post_id': self.object.id})

#변경
class PostCreateView(CreateView):
    model = Post
    form_class = PostForm

    def get_success_url(self):
        return reverse("post-detail", kwargs={'pk': self.object.id})

url 패턴에서 상세 페이지의 를 로 변경했으니 kwargs= 의 post_id를 pk로 변경해야 한다.

4. UpdateView

UpdateView에서 기본값이 할당된 데이터를 알아본다.

template_name 기본값은 모델명_detail.html 이므로 템플릿 이름이 일치한다면 삭제 가능

pk_url_kwarg 기본값은 pk 이므로 url 패턴에서 라면 삭제 가능

4.1 비교

기존에 작성된 코드와 기본값을 이용해 삭제한 변경된 코드를 비교하면 다음과 같다.

#기존
class PostUpdateView(UpdateView):
    model = Post
    form_class = PostForm
    template_name = "posts/post_form.html"  #기본값은 모델명_form.html
    pk_url_kwarg = "post_id"  #기본값은 pk

    def get_success_url(self):
        return reverse("post-detail", kwargs={"post_id": self.object.id})

#변경
class PostUpdateView(UpdateView):
    model = Post
    form_class = PostForm

    def get_success_url(self):
        return reverse("post-detail", kwargs={"pk": self.object.id})

url 패턴에서 수정 페이지의 를 로 변경했으니 kwargs= 의 post_id를 pk로 변경해야 한다.

5. DeleteView

DeleteView에서 기본값이 할당된 데이터를 알아본다.

template_name 기본값은 모델명_detail.html 이므로 템플릿 이름이 일치한다면 삭제 가능

pk_url_kwarg 기본값은 pk 이므로 url 패턴에서 라면 삭제 가능

context_object_name 기본값은 모델명 이므로 템플릿에 모델명으로 작성되었다면 삭제 가능

5.1 비교

기존에 작성된 코드와 기본값을 이용해 삭제한 변경된 코드를 비교하면 다음과 같다.

#기존
class PostDeleteView(DeleteView):
    model = Post
    template_name = "posts/post_confirm_delete.html"  #기본값은 모델명_confirm_delete.html
    pk_url_kwarg = "post_id"  #기본값은 pk
    context_object_name = "post"  #기본값은 모델명

    def get_success_url(self):
        return reverse("post-list")

#변경
class PostDeleteView(DeleteView):
    model = Post

    def get_success_url(self):
        return reverse("post-list")

제네릭 뷰 DeleteView

Fri, 19 Jan 2024 08:38:27 GMT

반복된 내용을 작성하기가 매우 힘이드니 약식으로 설명한다.

DeleteView를 상속하는 클래스형 뷰 생성

#views.py

class PostDeleteView(DeleteView):
    model = Post
    template_name = "posts/post_confirm_delete.html"
    pk_url_kwarg = "post_id"
    context_object_name = "post"

    def get_success_url(self):
        return reverse("post-list")

삭제 확인 페이지로 이동하기 위해 post_confirm_delete.html 템플릿을 렌더한다.

삭제 후 포스트 목록 페이지로 이동한다.

url 패턴 변경

#urls.py

urlpatterns = [
    # path('', views.index),
    path('', views.PostListView.as_view(), name="post-list"),
    path('posts/new/', views.PostCreateView.as_view(), name="post-create"),
    path('posts//', views.PostDetailView.as_view(), name="post-detail"),
    path('posts//edit/', views.PostUpdateView.as_view(), name="post-update"),
    path('posts//delete/', views.PostDeleteView.as_view(), name="post-delete"),
]

제네릭 뷰 UpdateView

Fri, 19 Jan 2024 08:30:04 GMT

제네릭 뷰와 관련된 이전 포스팅에서 반복했던 내용이기 때문에 간단하게 작성한다.

1. UpdateView를 상속받는 클래스형 뷰 생성

1.1 기존 함수형 뷰 post_update

기존에 작성한 함수형 뷰는 아래와 같다. 주석처리 한다.

#views.py

# def post_update(request, post_id):
#     post = get_object_or_404(Post, id=post_id)
#     if request.method == "POST":
#         post_form = PostForm(request.POST, instance=post)
#         if post_form.is_valid():
#             post_form.save()
#             return redirect("post-detail", post_id=post.id)
#     else:
#         post_form = PostForm(instance=post)
#     context = {"post_form": post_form}
#     return render(request, "posts/post_form.html", context)

1.2 변경된 클래스형 뷰 PostUpdateView

UpdateView 를 상속받는 클래스형 뷰 PostUpdateView를 작성한다.

#views.py > PostUpdateView

class PostUpdateView(UpdateView):
    model = Post
    form_class = PostForm
    template_name = "posts/post_form.html"
    pk_url_kwarg = "post_id"

    def get_success_url(self):
        return reverse("post-detail", kwargs={"post_id": self.object.id})

포스트 수정 페이지는 수정 후 해당 포스트의 상세 페이지로 이동하기 때문에 get_success_url 함수를 작성한다.

1.3 url 패턴 변경

url 패턴에서 post_update를 PostUpdateView로 변경해야 한다.

#urls.py

urlpatterns = [
    # path('', views.index),
    path('', views.PostListView.as_view(), name="post-list"),
    path('posts/new/', views.PostCreateView.as_view(), name="post-create"),
    path('posts//', views.PostDetailView.as_view(), name="post-detail"),
    path('posts//edit/', views.PostUpdateView.as_view(), name="post-update"),
    path('posts//delete/', views.post_delete, name="post-delete"),
]

제네릭 뷰 DetailView

Fri, 19 Jan 2024 08:19:32 GMT

장고의 DetailView 제네릭 뷰를 상속받는 상속 페이지를 구현하는 방법을 알아본다.

1. DetailView를 상속받는 클래스형 뷰 생성

1.1 기존 함수형 뷰 post_detail

기존에 작성된 함수형 뷰 post_detail은 아래와 같다. 주석처리 해준다.

#views.py

# def post_detail(request, post_id):
#     post = get_object_or_404(Post, id=post_id)
#     context = {"post": post}
#     return render(request, 'posts/post_detail.html', context=context)

1.2 변경된 클래스형 뷰 PostDetailView

DetailView를 상속받는 클래스형 뷰를 생성한다.

#views.py > PostDetailView

class PostDetailView(DetailView):
    model = Post
    template_name = "posts/post_detail.html"
    pk_url_kwarg = "post_id"
    context_object_name = "post"

접근할 모델을 정의하고, 렌더할 템플릿을 정의하고, url로부터 전달받는 인자를 정의하고, 데이터에 접근하기 위해 사용될 이름을 정의한다.

마찬가지로 context_object_name 변수에 지정한 값을 이용해 템플릿에서 해당 값을 통해 데이터에 접근할 수 있다.

또한 DetailView를 상속받기 위해서는 해당 클래스를 불러와야 한다.

1.3 url 패턴 변경

url 패턴에서 post_detail을 PostDetailView로 변경해야 한다.

#urls.py

urlpatterns = [
    # path('', views.index),
    path('', views.PostListView.as_view(), name="post-list"),
    path('posts/new/', views.PostCreateView.as_view(), name="post-create"),
    path('posts//', views.PostDetailView.as_view(), name="post-detail"),
    path('posts//edit/', views.post_update, name="post-update"),
    path('posts//delete/', views.post_delete, name="post-delete"),
]

제네릭 뷰 ListView

Fri, 19 Jan 2024 07:53:53 GMT

이전 포스팅에서는 게시글 작성 페이지를 CreateView를 통해 구현하는 방법을 배웠다. 본 포스팅에서는 게시글 목록 페이지를 ListView를 통해 구현하는 방법을 알아본다.

1. ListView를 상속받은 클래스형 뷰 생성

1.1 기존 함수형 뷰 post_list

기존에 작성된 함수형 뷰는 아래와 같다. 주석처리 해준다.

#views.py

# def post_list(request):
#     posts = Post.objects.all().order_by("-dt_modified")  #생성일 기준 내림차순으로 변경
#     page = request.GET.get("page", 1)  #GET 요청 방식일 때 url에서 로컬 호스트/ 다음 page에 해당하는 값을 가져오고 값이 없다면 1을 기본값으로 함
#     paginator = Paginator(posts, 9)  #posts를 페이지 당 9개씩 호출
#     page_obj = paginator.get_page(page)  #가져온 page 값에 해당하는 페이지의 데이터를 불러온다
#     context = {"page_obj": page_obj}
#     return render(request, 'posts/post_list.html', context=context)

다시봐도 상당히 복잡하다.

1.2 변경된 클래스형 뷰 PostListView

ListView 제네릭 뷰를 상속받은 클래스를 생성한다.

#views.py

class PostListView(ListView):
    model = Post
    template_name = "posts/post_list.html"
    context_object_name = "posts"
    ordering = ["-dt_created"]
    paginate_by = 9
    page_kwarg = 'page'

접근할 모델을 정의하고, 렌더할 템플릿을 정의하고, context로 전달할 객체 이름을 정의하고, 정렬 기준을 오름차순으로 정의하고, 페이지 당 표기되는 게시글 수를 정의하고, 현재 페이지를 조회하기 위해 전달하는 이름을 정의한다.

기존처럼 복잡한 구조가 아닌, 변수에 대한 값만 정해주면 훨씬 간단하게 작성할 수 있다.

1.2.1 주의할 점

ListView를 상속받기 위해서는 import 해야한다.

ListView는 context에 각 페이지에 해당하는 데이터를 전달할 때, 데이터의를 page_obj라는 키의 값으로 전달한다.

따라서 템플릿에서는 page_obj를 통해 각 페이지에 해당하는 데이터에 접근할 수 있다.

여기서 context_object_name 변수에 지정하는 값(여기서는 posts)을 통해서도 접근할 수 있다.

page_kwarg는 현재 페이지를 어떤 값으로 조회하는지를 전달한다.

이해를 위해 템플릿의 처음으로 버튼을 살펴보면 << 태그로 작성되어 있다.

여기서 url을 살펴보면 ?page=1로 작성된 것을 확인할 수 있는데 이는 1번 페이지로 이동하는 것을 말한다.

만약 템플릿에 작성된 page 이름이 pages로 변경되는 것과 같이 page_kwarg에 지정한 값과 다르다면, 원하는 페이지로 이동하지 못한다.

1.3 템플릿 수정

데이터에 접근하기 위한 템플릿 변수를 page_obj 또는 context_object_name에 지정한 값 posts 둘 중 하나를 사용해야 하는데, 프로젝트는 이미 page_obj로 사용하고 있기 때문에 변경하지 않아도 된다.



{% block content %}
    
        기록하기
    
    {% if page_obj %}
        
            {% for post in page_obj.object_list %}
                
                    {{post.title}}
                    {{post.dt_created|date:"Y년 m월 d일 H시 i분"}}
                    {{post.content}}
                
            {% endfor %}
        

        
            {% if page_obj.has_previous %}
                <<
            {% else %}
                <<
            {% endif %}

            {% if page_obj.has_previous %}
                <
            {% else %}
                <
            {% endif %}


            {% for page_number in page_obj.paginator.page_range %}
                {% if page_number == page_obj.number %}
                    {{ page_number }}
                {% elif page_obj.number <= 3 and page_number <= 5 %}
                    {{ page_number }}
                {% elif page_obj.number > page_obj.paginator.num_pages|add:-3 and page_number >= page_obj.paginator.num_pages|add:-4 %}
                    {{ page_number }}
                {% elif page_number >= page_obj.number|add:-2 and page_number <= page_obj.number|add:2 %}
                    {{ page_number }}
                {% endif %}
            {% endfor %}


            {% if page_obj.has_next %}
            >
            {% else %}
            >
            {% endif %}

            {% if page_obj.has_next %}
            >>
            {% else %}
            >>
            {% endif %}
        

        {% else %}
        
            
                등록된 게시글이 없습니다.

                게시글을 등록해보세요.
            
        
    {% endif %}

{% endblock content %}

1.4 url 패턴 변경

url 패턴에서 post_list를 PostListView로 변경해야 한다.

urls.py

urlpatterns = [
    # path('', views.index),
    path('', views.PostListView.as_view(), name="post-list"),
    path('posts/new/', views.PostCreateView.as_view(), name="post-create"),
    path('posts//', views.PostDetailView.as_view(), name="post-detail"),
    path('posts//edit/', views.post_update, name="post-update"),
    path('posts//delete/', views.post_delete, name="post-delete"),
]

제네릭 뷰 CreateView

Fri, 19 Jan 2024 07:12:41 GMT

클래스형 뷰가 개발자들이 자주 쓰는 기능들을 상위 클래스로 상속받아 사용한다면, 제네릭 뷰는 상속받을 수 있는 이미 만들어진 상위 클래스를 말한다.

CRUD에서 Read에 해당하는 클래스형 함수를 만들 때, 모델에 접근해 데이터를 불러오는 코드를 직접 작성하지 않고도 ListView 또는 DetailView 제네릭 뷰를 상속받으면 접근할 모델과 렌더할 템플릿 만 작성하면 된다.

1. PostCreateView를 제네릭 뷰를 사용해서 변경

이전 포스팅에 작성된 클래스형 함수 PostCreateView는 장고의 View를 상속받아 작성됐다. 제네릭 뷰를 상속받아 더 간편하게 CRUD의 CREATE 기능을 구현하는 방법을 알아본다.

1.1 PostCreateView 비교

기존에 작성된 코드와 제네릭뷰(CreateView)를 상속받아 작성된 코드를 비교해보자.

기존에 작성된 코드는 아래와 같다.

# class PostCreateView(View):
#     def get(self, request):
#         post_form = PostForm()
#         context = {"post_form": post_form}
#         return render(request, 'posts/post_form.html', context=context)

#     def post(self, request):
#         post_form = PostForm(request.POST)
#         if post_form.is_valid():
#             new_post = post_form.save()
#             return redirect("post-detail", post_id=new_post.id)
#         else:
#             context = {"post_form": post_form}
#             return render(request, 'posts/post_form.html', context=context)

제네릭 뷰(CreateView)를 상속받아 다시 작성된 코드는 아래와 같다.

class PostCreateView(CreateView):
    model = Post
    form_class = PostForm
    template_name = "posts/post_form.html"

    def get_success_url(self):
        return reverse("post-detail", kwargs={'post_id': self.object.id})

아래의 코드는 접근할 모델, 사용할 폼, 렌더할 템플릿, 그리고 게시글 생성 후 이동할 url만 작성했지만 기능은 일치한다.

그 이유는 상속받은 CreateView 제네릭 뷰에서 다른 내용들을 포함하고 있기 때문이다.

1.1.1 주의할 점

CreateView는 사용할 폼을 템플릿에 전달할 때 context에 {"form": {사용할 폼}}을 전달한다. 따라서 기존에 context로 전달하는 폼의 키가 다른 이름이라면 템플릿에서 변경해야 한다.

프로젝트에서는 기존에는 {"post_form":PostForm}으로 전달 했는데 키가 post_form 에서 form 으로 변경되어 전달되기 때문에 템플릿에서 해당 부분만 변경하면 된다.

reverse 함수는 redirect과는 다르게 url을 문자열로 생성하고 반환하는 역할만 한다. CreateView 제네릭 뷰에서 이미 해당 url로 이동하는 기능을 내장하고 있기 때문에 reverse를 사용하는 것 같다.

정확한 이해를 위해 각종 블로그를 찾아봤는데 redirect는 url 경로가 변경되면 변경된 경로를 모두 찾아 수정해야하고 reverse는 name 속성을 이용해 경로를 수정하지 않아도 된다는 내용이 많았다.

그러나 redirect도 마찬가지로 name 속성을 이용하면 url 경로를 하드코딩하지 않아도 되기 때문에 변경된 경로를 모두 찾아 수정할 필요가 없지 않나 라는 의문이 들었다.

해당 의문에 대한 명확한 답을 찾게된다면 다시 정리해서 수정하겠다.

1.2 url 패턴 변경

url 패턴에서 post_create를 PostCreateView로 변경해야 한다.

urls.py

urlpatterns = [
    # path('', views.index),
    path('', views.PostListView.as_view(), name="post-list"),
    path('posts/new/', views.PostCreateView.as_view(), name="post-create"),
    path('posts//', views.PostDetailView.as_view(), name="post-detail"),
    path('posts//edit/', views.post_update, name="post-update"),
    path('posts//delete/', views.post_delete, name="post-delete"),
]

클래스형 뷰

Fri, 19 Jan 2024 05:27:48 GMT

지금까지는 함수형 뷰를 사용했다. 함수형 뷰는 모든 로직을 직접 구현하기 때문에 직관적이지만, 클래스형 뷰를 사용하면 이미 작성된 상위 클래스를 상속받을 수 있어 더 간편하고 빠르게 뷰를 작성할 수 있다.

우리는 이미 클래스를 사용했다. 프로젝트의 Post 모델을 살펴보면 다음과 같다.

#posts/models.py > Post

class Post(models.Model):
    title = models.CharField(max_length=50, unique=True, error_messages={"unique":"이미 같은 제목의 게시글이 존재합니다"})
    content = models.TextField(validators=[MinLengthValidator(10, "10자 이상 입력해주세요"),
                                           validate_symbols])
    dt_created = models.DateTimeField(verbose_name="Date Created", auto_now_add=True)
    dt_modified = models.DateTimeField(verbose_name="Date Modified", auto_now=True)

    def __str__(self):
        return self.title

Post 모델은 장고의 modles.Model 클래스를 상속받아 사용하기 때문에 관련된 기능을 직접 구현하지 않아도 된다. 또한 __str__ 함수를 클래스 안에서 구현한다.

장고는 많은 개발자들이 자주 사용하는 여러 기능들을 클래스로 제공한다. CRUD와 같은 복잡한 기능들을 상위 클래스로 상속받으면 뷰를 더 쉽고 간편하게 작성할 수 있다.

1. 함수형 뷰를 클래스형 뷰로 변경

기존에 작성한 post_create 뷰를 클래스형 뷰로 작성하는 방법을 알아본다. 이를 위해 기존 코드를 주석처리 한다.

#views.py > post_create

# def post_create(request):
#     if request.method =="POST":
#         post_form = PostForm(request.POST)
#         if post_form.is_valid():
#             new_post = post_form.save()
#             return redirect("post-detail", post_id=new_post.id)
#         else:
#             context = {"post_form": post_form}
#     else:
#         post_form = PostForm()
#         context = {"post_form": post_form}
#     return render(request, 'posts/post_form.html', context=context)

1.1 클래스형 뷰 작성

기존의 함수형 뷰를 클래스형 뷰로 변경하기 위해서는 장고의 뷰 클래스를 상위 클래스로 상속 받아야 한다. 따라서 장고의 뷰 클래스를 불러온다.

#views.py

from django.views import View

이후 class를 생성하는데, 파스칼케이스 (Pascal Case) 관례를 따라서 언더바 없이 단어의 첫 글자를 대문자로 표기한다.

#views.py > PostCreateView

class PostCreateView(View):
    def get(self, request):
        post_form = PostForm()
        context = {"post_form": post_form}
        return render(request, 'posts/post_form.html', context=context)

    def post(self, request):
        post_form = PostForm(request.POST)
        if post_form.is_valid():
            new_post = post_form.save()
            return redirect("post-detail", post_id=new_post.id)
        else:
            context = {"post_form": post_form}
            return render(request, 'posts/post_form.html', context=context)

코드를 살펴보면 장고의 View 클래스를 상위 클래스로 두어 상속받는다.

또한 함수형 뷰와는 달리 if문으로 요청방식이 POST일 때와 GET일 때를 구분하지 않아도 된다.

이는 상위 클래스인 장고의 View에서 요청이 들어오면 요청과 같은 이름의 함수를 실행하는 함수를 상속받았기 때문이다.

1.2 url 패턴 변경

url 패턴에서 post_create 뷰를 불러오는 방식을 PostCreateView를 불러오는 방식으로 변경한다.

이때 클래스형 뷰는 함수형 부를 불러오는 방법과는 다르게 뒤에 .as_view()를 사용해야 한다.

#urls.py

urlpatterns = [
    # path('', views.index),
    path('', views.post_list, name="post-list"),
    path('posts/new/', views.PostCreateView.as_view(), name="post-create"),
    path('posts//', views.post_detail, name="post-detail"),
    path('posts//edit/', views.post_update, name="post-update"),
    path('posts//delete/', views.post_delete, name="post-delete"),
]

페이지 네이션

Thu, 18 Jan 2024 16:05:15 GMT

페이지 네이션을 만드는 방법을 알아본다.

1. views 수정

먼저 뷰를 수정해야 한다.

1.1 모듈 불러오기

장고의 페이지네이터를 불러온다.

#views.py

from django.core.paginator import Paginator

1.2 post_list 수정하기

post_list 함수를 수정한다.

views.py > post_list


def post_list(request):
    posts = Post.objects.all().order_by("-dt_modified")
    page = request.GET.get("page", 1)
    paginator = Paginator(posts, 9)
    page_obj = paginator.get_page(page)
    context = {"page_obj": page_obj}
    return render(request, 'posts/post_list.html', context=context)

요청으로부터 page 파라미터에 인자를 넘겨받아 변수 page에 지정한다. 만약 넘겨받은 인자가 없다면 1로 간주한다.

    page = request.GET.get("page", 1)

변수 posts의 데이터를 한 페이지 당 9개로 구분하고 변수 paginator에 지정한다.

    paginator = Paginator(posts, 9)

변수 paginator 를 통해 전체 데이터를 전체 데이터를 한 페이지 당 N개의 데이터로 나누고 변수 page와 일치하는 페이지 번호의 데이터들을 불러온 뒤 변수 page_obj에 지정한다.

    page_obj = paginator.get_page(page)

풀어서 설명하자면 아래와 같다. page_obj는 1. paginator를 통해 전체 데이터를 한 페이지 당 9개의 데이터로 구분 한 뒤, 2. 템플릿으로부터 파라미터로 전달받은 page의 값이 2라면, 3. 2페이지에 포함된 10번부터 18번까지의 데이터들을 호출한다.

context로 page_ojb를 넘겨준다.

    context = {"page_obj": page_obj}

요청과 context를 전달하면서 템플릿을 렌더한다.

    return render(request, 'posts/post_list.html', context=context)

1.3 템플릿 수정

우선 데이터를 호출하는 코드 중 기존 context로 넘겨받던 posts를 page_obj 로 변경했기 때문에 해당 부분을 변경해준다.

그런데 for 문에서 page_obj만 단독으로 사용하면 전체 게시글 개수, 전체 페이지 수, 이전 페이지 및 다음 페이지 존재 등은 확인할 수 있지만 데이터에는 접근할 수 없다. 따라서 페이지 내에 있는 데이터에 접근하기 위해서는 .object_list를 붙여줘야 한다.



    
        기록하기
    
    {% if page_obj %}
        
            {% for post in page_obj.object_list %}
                
                    {{post.title}}
                    {{post.dt_created}}
                    {{post.content}}
                
            {% endfor %}

1.3.1 페이지네이션 코드

이후 페이지네이션을 표기하는 코드를 작성한다.



        
            {% if page_obj.has_previous %}
                <<
            {% else %}
                <<
            {% endif %}

            {% if page_obj.has_previous %}
                <
            {% else %}
                <
            {% endif %}


            {% for page_number in page_obj.paginator.page_range %}
                {% if page_number == page_obj.number %}
                    {{ page_number }}
                {% elif page_obj.number <= 3 and page_number <= 5 %}
                    {{ page_number }}
                {% elif page_obj.number > page_obj.paginator.num_pages|add:-3 and page_number >= page_obj.paginator.num_pages|add:-4 %}
                    {{ page_number }}
                {% elif page_number >= page_obj.number|add:-2 and page_number <= page_obj.number|add:2 %}
                    {{ page_number }}
                {% endif %}
            {% endfor %}


            {% if page_obj.has_next %}
            >
            {% else %}
            >
            {% endif %}

            {% if page_obj.has_next %}
            >>
            {% else %}
            >>
            {% endif %}

무척 어려워 보이지만 전체적인 맥락을 파악하면 이해할 수 있다.

우리가 페이지네이션에서 만들어야할 것은 아래와 같다.

처음으로

이전으로

현재 페이지 기준 근접한 페이지

다음으로

마지막으로

1.3.2 처음, 이전, 다음, 마지막 버튼

먼저 처음으로와 이전으로를 살펴본다.

{% if page_obj.has_previous %}
    <<
{% else %}
    <<
{% endif %}
>
{% if page_obj.has_previous %}
    <
{% else %}
    <
{% endif %}

처음으로 버튼은 if문을 사용해 1. 이전 페이지가 있다면 page 파라미터에 1을 인자로 전달하는 태그를 생성 2. 이전 페이지가 없다면 클릭해도 반응이 없는 태그를 생성한다.

이전으로 버튼은 if문을 사용해 1. 이전 페이지가 있다면 page 파라미터에 이전 페이지의 page 번호를 인자로 전달하는 태그를 생성 2. 이전 페이지가 없다면 클릭해도 반응이 없는 태그를 생성한다.

다음으로와 마지막으로 버튼을 이와 비슷하니 따로 설명하지 않겠다.

1.3.3 현재 페이지 기준 근접한 페이지

이 부분은 page_obj에 사용된 paginator를 통해 페이지의 전체 범위를 반복해 page_number를 찾는다.

{% for page_number in page_obj.paginator.page_range %}
    {% if page_number == page_obj.number %}
        {{ page_number }}
    {% elif page_obj.number <= 3 and page_number <= 5 %}
        {{ page_number }}
    {% elif page_obj.number > page_obj.paginator.num_pages|add:-3 and page_number >= page_obj.paginator.num_pages|add:-4 %}
        {{ page_number }}
    {% elif page_number >= page_obj.number|add:-2 and page_number <= page_obj.number|add:2 %}
        {{ page_number }}
    {% endif %}
{% endfor %}

첫번 째 if문은 현재 반복중인 페이지가 현재 페이지와 일치하면 클릭해도 반응없는 태그를 생성하기 위함이다.

나머지 elif문은 현재 페이지에 따라서 총 5개의 인접한 페이지만 호출되도록 제한하는 내용이다.

그 외 중앙정렬, 폰트, 호버 등 간단한 css를 적용하기 위해 태그별로 클래스를 지정했다.

페이지네이션은 직접 완벽하게 만들기에는 많이 복잡하다. 웬만하면 남이 작성한 코드를 사용하자.

더미데이터 유효성 검증

Thu, 18 Jan 2024 06:41:18 GMT

데이터 시딩을 통해 더미데이터를 추가했지만, 유효성이 관리되지 않는다. 따라서 본 포스팅은 프로젝트에 추가된 더미데이터를 유효성 검증에 통과된 데이터로 변경하는 방법을 알아본다.

1. 더미데이터 확인

데이터 시딩을 통해 생성된 데이터 중, 유효성 검증에 통과하지 못한 데이터는 다음과 같다.

특수문자 &이 포함됨

이미지에는 보이지 않지만 수정일이 생성일보다 빠름

2. py 파일 및 함수 작성

수정일이 생성일보다 빠른 게시글을 찾아 수정일을 현재 시간으로 변경하고

내용에 &가 포함된 게시글을 찾아 &를 삭제하는 파이썬 파일을 작성한다.

파일 이름은 validate_data로 생성했다.

#posts > validate_data.py

from .models import Post

def validate_post():
    posts = Post.objects.all()

    for post in posts:
        if "&" in post.content:
            print(post.id, "번 글에 &가 있음")
            post.content = post.content.replace("&", " ")
            post.save()

        if post.dt_modified < post.dt_created:
            print(post.id, "번 글의 수정일이 생성일보다 과거임")
            post.save()

2.1 각 코드의 의미

Post 모델을 불러온다.

from .models import Post

validate_post 이름의 함수를 작성한다.

def validate_post():

변수 posts에 Post 모델의 모든 데이터를 지정한다.

    posts = Post.objects.all()

posts에 담긴 데이터를 post 라는 이름으로 하나씩 불러온다.

    for post in posts:

만약 & 특수문자가 post의 content 필드에 있다면 해당 post의 id를 호출한다. 그리고 해당 post의 content 필드에서 &를 로 대체한다. 이후 post를 저장한다.

        if "&" in post.content:
            print(post.id, "번 글에 &가 있음")
            post.content = post.content.replace("&", " ")
            post.save()

만약 post의 dt_modified 필드의 값이 de_created보다 낮다면, 해당 post의 id를 호출한다. 그리고 해당 post를 저장한다.

        if post.dt_modified < post.dt_created:
            print(post.id, "번 글의 수정일이 생성일보다 과거임")
            post.save()

(dt_modified는 auto_now 옵션을 True로 정의했기 때문에 저장하면 현재시간으로 변경된다.)

3. shell 환경에서 파일 사용

작성된 파일을 shell 환경에서 사용한다.

python manage.py shell

작성된 파일의 validate_post 함수를 불러온다.

from posts.validate_data import validate_post

불러온 함수를 사용한다.

validate_post()

3.1 콘솔 결과

3.2 서버 결과

& 특수문자가 모두 제거됨

수정일이 현재시간으로 변경됨

데이터 추출과 삽입

Wed, 17 Jan 2024 05:45:03 GMT

프로젝트에서 더미 데이터를 삽입하려 한다. 데이터를 삽입하는 것을 seeding 이라고 한다. 이번에는 데이터를 시딩하는 두 가지 방법을 알아본다.

1. loaddata를 통한 시딩

loaddata는 미리 작성된 데이터 파일을 통해 데이터를 시딩하는 방법이다.

데이터 파일은 json 또는 xml 의 형식을 사용할 수 있다.

본 포스팅에서는 json 형식의 파일을 통해 loaddata하는 방법을 알아본다.

1.1 json 파일 추출

json은 데이터를 표현하기 위해 사용하는 대표적인 포맷이다. 파이썬의 사전형 자료와 유사하며, 데이터를 키와 값을 쌍으로 이루어 표현한다.

우리 프로젝트의 데이터가 json 형식으로 저장되면 어떤 모습일지는 데이터를 추출해보면 된다.

python manage.py dumpdata posts --indent=2 > posts_data.json

명령어를 살펴보면 posts 앱의 데이터를 posts_data.json 파일로 저장한다는 의미이며 indent는 각 코드의 들여쓰기를 의미한다. indent를 사용하면 데이터가 보기 좋게 정렬된다.

#posts_data.json

[
{
  "model":"posts.post",
  "pk": 1,
  "title": abc1,
  "content": abcdefg,
}
]

1.2 json 파일 수정

추출한 json 파일의 형식에 맞게 데이터를 추가한다.

#posts_data.json

[
{
  "model":"posts.post",
  "pk": 1,
  "title": abc1,
  "content": abcdefg,
},
{
  "model":"posts.post",
  "pk": 2,
  "title": abc2,
  "content": abcdefg,
}
]

1.3 json 파일을 데이터 베이스에 적용

수정한 json을 데이터베이스에 적용한다.

python manage.py loaddata posts_data.json

loaddata를 사용하면 posts_data.json 파일을 데이터베이스에 적용한다. 추가되는 것이 아닌, 기존의 데이터를 덮어쓰는 것을 주의해야 한다.

어떤 모델의 데이터베이스에 적용되는지는 json 파일의 model 키의 값 에 따라 결정된다. 따라서 하나의 json 파일에서 여러 모델의 데이터베이스를 추가할 수 있다.

2. django-seed를 통한 시딩

만약 생성해야 할 데이터가 많다면, dumpdata를 통해 json 파일을 추출하고, 해당 json 파일에 데이터를 복사한 뒤, 복사한 데이터 수 만큼 pk값을 모두 변경해야 한다. 이런 번거로움을 django-seed를 통해 해결할 수 있다.

2.1 django-seed 설치

django-seed를 설치한다. 프로젝트의 가상환경은 django 2.2 버전을 사용하고 있어, 해당 버전과 호환되는 django_seed 0.2.2를 설치한다.

pip install django-seed==0.2.2

2.2 django-seed 앱 등록

django-seed를 사용하기 위해 프로젝트 구성 디렉토리의 settings.py에 등록한다. 주의할 점은 하이픈이 아닌 언더바를 넣어 django_seed로 등록해야 한다.

#settings.py > INSTALLED_APPS

INSTALLED_APPS = [
    'django.contrib.admin',
    'django.contrib.auth',
    'django.contrib.contenttypes',
    'django.contrib.sessions',
    'django.contrib.messages',
    'django.contrib.staticfiles',
    'posts',
    'django_seed'  #하이픈이 아닌 언더바
]

2.3 seed 명령어 사용

시딩을 위한 준비가 끝났으니 seed 명령어를 통해 10개의 데이터를 추가해본다.

python manage.py seed posts --number=10

posts는 앱 이름이며 number는 생성할 데이터를 의미한다.

seed 명령어는 지정한 앱의 모든 모델의 데이터를 지정한 데이터 수 만큼 생성한다.

또한 seed 명령어는 유효성 검증을 무시한 채로 데이터를 생성하므로, 유효성 검증과 관련해서는 직접 데이터를 관리해야 한다.

2.3.1 특정 모델의 데이터만 생성

특정 모델의 데이터만 생성하고 싶다면 --seeder 옵션을 사용해 모델 이름을 입력하면 된다.

아래의 경우 posts 앱의 Post 모델에 5개의 데이터를 생성한다.

python manage.py seed posts --number=5 --seeder Post

2.3.2 특정 필드에 특정 데이터를 지정

특정 모델의 데이터를 생성하면서, 특정 필드의 값을 지정하고 싶다면

--seeder 옵션에서 모델이름에 .필드이름 붙이고 "로 감싼 형태로 입력한다.

그리고 원하는 값을 "로 감싼 형태로 입력한다.

아래의 경우 posts 앱의 Post 모델에 title 필드의 값이 dummy title인 5개의 데이터를 생성한다.

python manage.py seed posts --number=5 --seeder "Post.title" "dummy title"

2.3.2 여러 필드에 특정 데이터를 지정

특정 모델의 데이터를 생성하면서, 여러 필드의 값을 지정하고 싶다면 --seeder 옵션을 추가하기만 하면 된다.

아래의 경우 posts 앱의 Post 모델에 title 필드의 값이 dummy title이며, content 필드의 값이 dummy content인 5개의 데이터를 생성한다.

python manage.py seed posts --number=5 --seeder "Post.title" "dummy title" --seeder "Post.content" "dummy content"

get_object_or_404

Wed, 17 Jan 2024 04:20:21 GMT

1. Post.objects.get(id= post_id)

프로젝트에서 기존에 작성된 뷰는 게시글을 불러올 때 Post 모델에서 id가 post_id와 일치하는 게시글을 불러왔다.

그러나 post_id와 일치하는 게시글이 없는 경우 에러 페이지를 렌더했다.

이 경우 유저는 잘못된 접근인지, 서버 오류인지를 구분하기가 어려웠다.

2. get_object_or_404()

따라서 모델의 데이터를 불러오고, 해당 데이터가 없는 경우에는 404 에러를 불러오는 get_object_or_404를 알아본다.

우선 장고 숏컷 모듈에서 해당 함수를 불러온다.


from django.shortcuts import get_object_or_404

이후 기존에 사용했던 Post.objects.get(id = post_id)를 변경한다. 그리고 변수 post에 지정한다.

파라미터에는 참조할 모델 클래스(Post)와 조건(id=post_id)을 인자로 넘겨준다.


post = get_object_or_404(Post, id = post_id)

이 경우 post_id와 일치하는 id를 가진 데이터를 Post 모델에서 찾아보고

해당 데이터가 있다면 변수 post에 지정하지만

해당 데이터가 없다면 404 에러를 불러온다.

모델의 데이터가 없을 때

Wed, 17 Jan 2024 04:03:52 GMT

1. 모델의 데이터가 비어있는 경우

모델의 데이터가 비어있는 경우 빈 페이지를 보여주기 보다는, 데이터가 비어있음을 안내해야 한다.

1.1 if문을 통한 구분

if문을 통해 작성된 html을 살펴본다.



{% block content %}
    
        기록하기
    
    {% if posts %}
        
            {% for post in posts %}
                
                    {{post.title}}
                    {{post.dt_created}}
                    {{post.content}}
                
            {% endfor %}
        
    {% else %}
        
            
                등록된 게시글이 없습니다.

                게시글을 등록해보세요.
            
        
    {% endif %}

{% endblock content %}

템플릿 태그 if 를 활용

posts가 있다면, 각 포스트의 내용을 불러오고

posts가 없다면
태그로 등록된 게시글이 없음을 안내한다.

여기서 posts는 view를 통해 전달받은 데이터를 말한다.

1.2 결과

Django Form

Tue, 09 Jan 2024 11:04:34 GMT

1. 폼이란?

1.1 폼이란?

웹 서비스에서 사용자가 데이터를 입력하고 서버에 전송하기 위한 방식을 말한다.

CRUD 에서 Read 는 데이터베이스에서 데이터를 가져와서 템플릿으로 렌더해 사용자에게 전달하면 된다.

Create 는 이와 반대로 사용자의 입력을 받고 서버로 전송해야 하는데 이때 사용되는 것이 form이다.

1.2 폼 예시


  이름
  
  별명

2. 폼 처리 과정

폼을 이해하기 위해 폼이 어떻게 처리되는지 살펴본다.

2.1 Method

클라이언트가 서버에 보내는 모든 request는 종류에 따라 구분되며, 가장 많이 사용되는 것이 GET과 POST 방식이다.

2.1.1 GET

GET은 서버에 데이터를 조회하기 위한 메서드이다.

GET은 요청에 포함하고 싶은 데이터가 있을 때 필요한 데이터를 url에 담아서 요청한다.

#예시 http://dear.com/profile?name=홍길동&email=gildong@dear.com

예시에서 dear.com/profile 까지는 url이고 ?다음 문자열이 필요한 데이터를 표현하는 쿼리 스트링이다.

위 url은 이름이 홍길동이고 email이 gildong@dear.com인 유저의 프로필을 조회한다고 보면 된다.

정리하자면 쿼리 스트링은 url의 마지막 ? 다음에 표현되며 키와 밸류의 쌍으로 데이터를 표시하고 각각의 데이터는 & 으로 구분한다.

그러나 민감한 데이터가 url에 노출된 채로 서버로 전송될 수 있기 때문에 POST의 방식을 더 많이 사용한다.

2.1.2 POST

POST 방식에서는 필요한 데이터를 url이 아닌, 클라이언트와 서버가 통신하는 메세지 내부에 담기 떄문에 데이터 노출 우려가 적다.

2.1.3 간단히

간단히 말해서 서버의 데이터를 조회만 하는 것이라면 GET 방식이고, 서버의 데이터를 변경(생성, 수정, 삭제)하는 것은 POST 방식이다.

2.2 폼의 처리 과정

폼의 처리 과정을 단계별로 구분하면 다음과 같다.

2.2.1 클라이언트의 요청

클라이언트가 폼을 작성하기 위해 서버에 폼 양식을 요청한다.

이미 서버에서 가지고 있는 폼 양식을 조회하는 것이므로 GET 방식으로 요청한다.

이 때 서버가 폼 양식을 전달하는데, 데이터가 폼과 연결되어 있지 않기 때문에 이를 언바운드 폼이라 한다.

아래 처럼 비어 있는 폼을 생각하면 된다.

2.2.2 사용자의 데이터 전송

사용자가 데이터를 입력하고 서버에 전송한다.

method 에 작성된 방식으로 action에 해당하는 url로 데이터를 전송한다.


  이름
  
  별명

여기서는 POST 방식으로 로컬호스트:8000/complate 에 입력된 이름과 별명을 전송한다.

2.2.3 바인딩

서버에서 전달받은 데이터와 폼을 합쳐서 하나의 형태로 만들며 이를 바인딩이라 하며, 데이터와 합쳐진 폼을 바운드 폼이라 한다.

2.2.4 바운드 폼 확인

바운드 폼의 데이터가 유효하지 않은 경우, 사용자에게 다시 폼을 입력하도록 안내한다.

2.2.5 로직 수행

바운드폼의 데이터가 유효하다면 서버의 로직을 수행한다.

데이터를 가공하거나, 수정하거나, 저장한다.

2.2.6 응답

로직 수행이 끝났다면 새로운 페이지를 응답으로 돌려준다.

3. 폼 구조

폼의 구조는
태그 안에 태그와 태그로 구성된다.

3.1 form 태그

폼 태그는 데이터를 어디로 전송해야 하는지 url 경로를 작성하는 action 속성과 어떤 방식으로 요청을 보내는지를 정의하는 method 속성이 있다.

만약 action 속성과 method 속성을 입력하지 않으면 action 은 현재 url, method 는 GET 방식으로 설정된다. 즉, form에 입력된 데이터를 가지고 현재 url을 다시 불러온다.

3.2 label 태그

레이블 태그는 특정 인풋 태그와 연결하기 위한 for 속성이 있다.

레이블 태그의 for 속성에 입력되는 값과, 인풋 태그의 id 속성에 입력되는 값이 일치하는 해당 레이블 태그와 인풋 태그가 연결된다.

  이름

만약 레이블 태그의 for 속성과 인풋 태그의 id 속성을 적고싶지 않다면 레이블 태그로 인풋 태그를 감싼 형태를 만들면 된다

  이름

다만 css 적용을 위해서는 id 속성을 작성해야 한다.

3.3 input 태그

id 속성은 위에서 설명했으니 넘어가고 name 속성과 type 속성만 알아본다.

name 속성은 폼에 입력한 데이터를 서버로 전송할 때, 서버에서 각가의 데이터를 구분할 수 있게 한다. name 속성이 없는 인풋 태그는 값이 서버로 전달되지 않는다.

type 속성은 입력되는 유형을 지정하는 속성이다. type 속성에 따라 입력하는 위젯이 달라진다.

무료 html 템플릿 사이트

Mon, 08 Jan 2024 06:43:43 GMT

무료로 반응형 html 템플릿을 제공하는 사이트

https://html5up.net/ https://colorlib.com/

Django Model API

Fri, 05 Jan 2024 08:37:24 GMT

장고의 Model을 통해서 데이터베이스의 데이터를 Queryset으로 불러올 수 있다. 여기서 우리는 Model API를 통해 Queryset을 원하는 조건으로 불러올 수 있다.

1. Queryset API

1.1. all()

해당 모델 테이블의 모든 데이터 조회

all()
>
#예시
Post.objects.all()

1.2. filter()

특정 조건에 맞는 모든 데이터 조회

filter()
>
#예시
Post.objects.filter({필드}{필드조건옵션}={조건})

1.3. exclude()

특정 조건을 제외한 모든 데이터 조회

exclude()
>
#예시
Post.objects.exclude({필드}{필드조건옵션}{조건})

1.4. order_by()

특정 조건으로 정렬된 데이터 조회 기본값은 내림차순 / -를 붙이면 오름차순

order_by()
>
#예시
Post.objects.order_by({필드})
Post.objects.order_by({-필드})

1.5. values()

Queryset에 있는 모든 모델 데이터의 모든 정보를 사전형으로 갖는 리스트로 반환

values()
>
#예시
Post.objects.all().values()

1.6. get()

조건에 맞는 하나의 데이터 조회

get()
>
#예시
Post.objects.get({조건})

1.7. create()

하나의 데이터를 생성하고 해당 모델 데이터를 반환

create()
>
#예시
Post.objects.create({필드}={값})

1.8. get_or_create()

조건에 맞는 데이터를 조회, 해당 데이터가 없다면 새로 생성 후 새로 생성된 모델 데이터를 반환

get_or_create()
>
#예시
Post.objects.get_or_create({필드}={값})

1.9. latest()

주어진 필드 기준으로 가장 최신의 모델 데이터를 반환

latest()
>
#예시
Post.objects.latest({필드})

1.10. first()

Queryset의 가장 첫번 째 모델 데이터를 반환, 만약 정렬하지 않은 Queryset인 경우 pk를 기준으로 정렬 후 반환

first()
>
#예시
Post.objects.order_by({필드}).first()

1.11. last()

Queryset의 가장 마지막 모델 데이터를 반환

last()
>
#예시
Post.objects.order_by({필드}).last()

1.12. exists()

Queryset에 데이터가 있다면 True 반환

exists()
>
#예시
Post.objects.get({조건}).exists()

1.13. count()

Queryset의 데이터 개수를 정수로 반환

count()
>
#예시
Post.objects.all().count()

1.14. update()

데이터를 수정할 때 사용하며, 여러 데이터 또는 필드를 한 번에 수정할 수 있음 수정 후 수정된 데이터의 개수를 정수로 반환

update()
>
#예시
Post.objects.filter({조건}).update({변경내용})

2. 필드 조건 옵션

2.1. __contains

대소문자를 구분하여 문자열 포함 여부 확인

#예시
Post.objects.get({필드}__contains={값})

2.2. __icontains

대소문자를 구분하지 않고 문자열 포함 여부 확인

#예시
Post.objects.get({필드}__icontains={값})

2.3. __in

반복 가능한 객체 안에서의 포함 여부를 확인

#예시
Post.objects.filter({필드}__in=[{값1}, {값2}, {값3}])

2.4. __gt

초과 여부 확인

#예시
Post.objects.filter({필드}__gt={값})

2.5. __gte

이상 여부 확인

#예시
Post.objects.filter({필드}__gte={값})

2.6. __lt

미만 여부 확인

#예시
Post.objects.filter({필드}__lt={값})

2.7. __lte

이하 여부 확인

#예시
Post.objects.filter({필드}__lte={값})

2.8. __startswith

대소문자를 구분하여 해당 문자열로 시작하는지 여부 확인

#예시
Post.objects.filter({필드}__startswith={값})

2.9. __istartswith

대소문자를 구분하지 않고 해당 문자열로 시작하는지 여부 확인

#예시
Post.objects.filter({필드}__istartswith={값})

2.10. __endswith

대소문자를 구분하여 해당 문자열로 끝나는지 여부 확인

#예시
Post.objects.filter({필드}__endswith={값})

2.11. __iendswith

대소문자를 구분하지 않고 해당 문자열로 끝나는지 여부 확인

#예시
Post.objects.filter({필드}__iendswith={값})

2.12. __range

range로 제시하는 범위 내에 포함되는지 확인

#예시
Post.objects.filter({필드}__range={시작값}, {끝값})

2.13. __isnull

해당 필드가 Null 인지 여부를 확인

#예시
Post.objects.filter({필드}__isnull=True)

프로젝트

Thu, 04 Jan 2024 09:25:41 GMT

1. 프로젝트 개요

Django CRUD를 학습하면서, Dear 프로젝트를 만들어 볼 것이다.

1.1 Dear의 의미

Dear은 Daily Events and Affective Reactions의 약어다.

1.2 주요 특징

서비스의 주요 특징은 사용자가 오늘 하루 있었던 일과 관련된 경험 태그 하나와 그로 인해 느낀 감정 태그 하나를 선택하여 글을 작성하고, 다른 사람들이 작성한 글 중, 태그가 일치하는 글을 볼 수 있는 것이다.

1.3 기대 효과

Dear은 일상의 사건과 감정을 중심으로 하는 소셜 네트워크로서, 사용자들이 자신의 경험을 기반으로 비슷한 경험을 한 사용자를 찾아 서로의 이야기에 공감하며 상호작용하는 공간을 제공할 수 있다.

2.프로젝트 생성 및 설정

2.1 가상환경 설정

Dear 프로젝트를 생성하기 전, 가상환경 설정을 위해 django 디렉토리를 하나 생성해준다.

mkdir django

django 디렉토리에 기존에 생성해둔 django-envs 가상환경을 적용해준다

cd django
pyenv local django-envs

2.2 장고 프로젝트 생성

Dear 프로젝트를 생성한다.

django-admin startproject dear

프로젝트 루트로 이동 후 vscode를 실행한다.

cd dear
code .

2.3 프로젝트 초기 설정

settings.py에서 타임존을 한국 시간으로 변경한다.

#settings.py

TIME_ZONE = 'Asia/Seoul'

2.4 앱 생성

posts 앱을 생성한다. 터미널에서 명령어를 입력한다.

python manage.py startapp posts

앱을 생성한 뒤에는 settings.py에서 등록해야 한다.

#settings.py

INSTALLED_APPS = [
    'django.contrib.admin',
    'django.contrib.auth',
    'django.contrib.contenttypes',
    'django.contrib.sessions',
    'django.contrib.messages',
    'django.contrib.staticfiles',
    'posts'  #등록
]

위를 살펴보면 posts 말고도 장고가 기본적으로 제공하는 앱들이 있다. 해당 앱들이 필요로 하는 데이터 구조를 생성하기 위해서 migrate 명령어를 입력한다.

python manage.py migrate

명령어를 입력하면 db.sqlite3 파일이 생성된 것을 확인할 수 있다.

2.5 개발서버 실행

개발 서버를 실행하고 서버가 정상적으로 동작하는지 확인한다.

python manage.py runserver

아래와 같이 잘 동작하는 것을 알 수 있다.

3. URL 구조 작성

Dear의 url 구조는 다음과 같다.

홈페이지
내가 작성한 포스트 목록 (R)
오늘 내가 작성한 포스트와 태그가 일치하는 포스트 목록 (R)
포스트 상세 (R)
포스트 작성 (C)
포스트 수정 (U)
포스트 삭제 (D)

다만 현재 학습하는 토픽에서는 기본적인 포스팅 구조만을 배우고 있기에 하단의 url 구조를 따르고, 추후 변경하는 것을 목표로 한다.

홈페이지
전체 포스트 목록 (R)
포스트 상세 (R)
포스트 작성 (C)
포스트 수정 (U)
포스트 삭제 (D)

3.1 프로젝트 구성 디렉토리 URL 패턴 작성

프로젝트 구성 디렉토리의 urls.py 를 작성한다.

#dear/urls.py

from django.contrib import admin
from django.urls import path, include  #include 추가

urlpatterns = [
    path('admin/', admin.site.urls),
    path('', include('posts.urls')),  #작성
]

이렇게 작성하면 로컬호스트:8000으로 접속하거나 로컬호스트:8000/빈url로 접속하면 가장 먼저 posts 앱의 urls를 확인하게 된다.

3.2 posts 앱 URL 패턴 작성

posts 앱에 urls가 없으니 새로 생성하고 코드를 작성해 준다.

#posts/urls.py

from django.urls import path  #작성
from . import views  #작성

urlpatterns = [
    path('', views.index),
    path('posts/', views.post_list),
    path('posts/new', views.post_create),
    path('posts/', views.post_detail),
    path('posts//edit', views.post_update),
    path('posts//delete', views.post_delete),
]

3.2.1 각 코드의 의미

기본적으로 로컬호스트:8000/ 으로 접속하면 장고는 프로젝트 구성 디렉토리의 url 패턴에 따라 posts 앱의 url 패턴을 확인한다.

path('', views.index) 는 로컬호스트:8000/{빈 url}로 접속하면 views의 index 함수를 확인하라는 내용이다.

path('posts/', views.post_list)는 로컬호스트:8000/posts로 접속하면 views의 post_list 함수를 확인하라는 내용이다.

path('posts/new', views.post_create)는 로컬호스트:8000/posts/new로 접속하면 views의 post_create 함수를 확인하라는 내용이다.

path('posts/', views.post_detail)는 로컬호스트:8000/posts/{url}로 접속하면 {url}을 정수로 보고 post_id에 담아서 views의 post_detail 함수를 확인하라는 내용이다.

path('posts//edit', views.post_update)는 로컬호스트:8000/posts/{url}/edit으로 접속하면 {url}을 정수로 보고 post_id에 담아서 views의 post_update 함수를 확인하라는 내용이다.

path('posts//delete', views.post_delete)는 로컬호스트:8000/posts/{url}/delete로 접속하면 {url}을 정수로 보고 post_id에 담아서 views의 post_delete 함수를 확인하라는 내용이다.

3.2.2 URL 패턴 주석처리

현재는 각 url 패턴과 매칭되는 views가 정의되지 않았으니 개발 서버를 실행하면 에러가 날 것이다. 따라서 url 패턴을 주석처리 해둔다.

from django.urls import path
from . import views

urlpatterns = [
    # path('', views.index),
    # path('posts/', views.post_list),
    # path('posts/new', views.post_create),
    # path('posts/', views.post_detail),
    # path('posts//edit', views.post_update),
    # path('posts//delete', views.post_delete),
]

4. model 정의

4.1 Post 모델 정의

데이터베이스에 접근하기 위해서는 model을 정의해줘야 한다. posts 앱 디렉토리의 models.py를 작성한다.

#posts/models.py

from django.db import models

class Post(models.Model):
    title = models.CharField(max_length=50)
    content = models.TextField()
    dt_created = models.DateTimeField(verbose_name="Date Created", auto_now_add=True)
    dt_modified = models.DateTimeField(verbose_name="Date Modified", auto_now=True)

    def __str__(self):
        return self.title

4.1.1 각 코드의 의미

from django.db import models 장고 프레임워크의 db 모듈에서 models 클래스를 불러온다

class Post(models.Model): Post 라는 이름의 모델 클래스를 생성한다.

title = models.CharField(max_length=50) Post 모델에 최대 길이가 50인 문자열 컬럼 title을 추가한다.

content = models.TextField() Post 모델에 최대 길이 제한이 없는 문자열 컬럼 content를 추가한다.

dt_created = models.DateTimeField(verbose_name="Date Created", auto_now_add=True) Post 모델에 Date Created라는 별명을 가졌으며 인스턴스 생성 시 생성 시간이 자동으로 입력되는 컬럼 dt_created를 추가한다.

dt_modified = models.DateTimeField(verbose_name="Date Modified", auto_now=True) Post 모델에 Date Modified라는 별명을 가졌으며 인스턴스 변경 시 변경 시간이 자동으로 입력되는 컬럼 dt_modified를 추가한다.

마지막 던더 str 함수는 title을 문자열로 반환하는 역할을 한다. shell 환경에서 데이터를 불러오면 각 데이터의 title을 표기한다.

def __str__(self):
    return self.title

4.2 migration 생성 및 mirgrate

모델이 생성되거나 변경되면 makemigrations으로 새로운 migrations 파일을 생성하고 migrate를 통해 실제 데이터베이스에 적용해야 한다. 터미널에서 아래의 명령어를 입력한다.

python manage.py makemigrations  #migration 파일 생성
python manage.py migrate  #데이터베이스에 적용

5. 더미데이터

5.1 더미데이터 생성

더미데이터를 생성하는 방법을 알아보자

shell 환경을 불러온다.

python manage.py shell  #shell 환경을 불러오는 명령어

모델의 Post 클래스를 불러온다.

from posts.models import Post  #posts 디렉토리의 모델 파일에서 Post 클래스를 불러온다

데이터가 있는지 확인하기 위해 모든 데이터를 불러온다.

Post.objects.all()  #모든 데이터를 불러오는 명령어

아직 생성된 데이터가 없으니 데이터를 수동으로 생성해본다.

Post.objects.create(title = "기분 좋은 날",content = "오늘은 평소와 달리 기분 좋은 아침을 맞이했다.")

데이터가 생성 되었다면 다음과 같이 출력될 것이다.

출력 결과에 위처럼 데이터의 title이 호출되는 이유는 던더 str 함수에서 self.title을 반환하기 때문이다

def __str__(self):
    return self.title

생성된 데이터를 자세히 살펴보기 위해 아래의 명령어를 실행하면

Post.objects.all().values()  #모델의 모든 데이터를 모든 컬럼의 값을 포함하여 호출

다음과 같이 출력된다.

Post 클래스의 dt_created와 dt_modified 컬럼은 auto_now와 auto_now_add 속성을 사용했기 때문에 직접 입력하지 않아도 자동으로 생성되는 것을 확인할 수 있다.

5.2 더미데이터 수정

이번에는 더미데이터를 수정하는 방법을 알아보자.

데이터 수정을 위해서는 먼저 데이터를 불러와야 한다. 따라서 post라는 변수에 id가 1인 객체를 지정한다.

post = Post.objects.get(id=1)  #id가 1인 객체를 post 변수에 삽입

post.title을 입력해 현재 title을 확인한다.

post.title  #post변수의 안쪽 속성에 접근해 title 컬럼의 값을 확인

이제 post 변수에 담긴 데이터의 title을 변경해보자.

post.title = "기분이 너어무 좋은 날"

post.title로 확인해보니 변경이 완료됐다.

데이터베이스에서도 변경되었는지 확인해보자.

Post.objects.all()

변경되지 않았다. 여전히 "기분 좋은 날"로 나타난다.

그 이유는 저장을 하지 않았기 때문이다.

post.save()  #데이터 변경내용 저장

저장하고 다시 확인해보면 title과 dt_modified가 변경된 것을 확인할 수 있다.

5.2.1 dt_created와 dt_modified가 안맞는다?

분명 settings.py의 타임존을 Asia/Seoul 로 변경했는데 왜 모델 인스턴스의 시간은 UTC로 표기가 되는 것일까?

이는 settings.py의 USE_TZ와 관련있다. 장고는 USE_TZ = True인 경우 설정한 타임존이 템플릿과 폼에만 영향을 끼친다. 따라서 USE_TZ = False로 변경하면 해결된다.

5.3 관리자 페이지에서 데이터 수정

이번에는 shell 환경이 아닌 관리자 페이지에서 데이터를 수정해보자.

5.3.1 관리자 페이지에 모델 등록

admin.py에 Post 모델을 등록한다.

#posts/admin.py
>
from django.contrib import admin
from .models import Post  #모델에서 Post 클래스를 불러온다
>
# Register your models here.
admin.site.register(Post)  #Post를 관리자 페이지에 등록한다

5.3.2 관리자 계정 생성

shell 환경을 종료한다.

exit()  #shell 환경 종료

관리자 계정을 생성한다.

python manage.py createsuperuser  #관리자 계정 생성

5.3.3 관리자 페이지 접속

개발서버를 실행한다.

python manage.py runserver

로컬호스트:8000/admin으로 접속한다.

관리자로 로그인하면 Posts가 생성된 것을 확인할 수 있다.

Posts를 클릭하면 shell 환경으로 작성한 데이터를 확인할 수 있다.

6. 포스트 목록 페이지 만들기

6.1 url 패턴 주석 해제

posts 앱 디렉토리의 urls.py의 url 패턴 중 포스트 목록 페이지에 해당하는 코드를 주석 해제 한다.

from django.urls import path
from . import views

urlpatterns = [
    # path('', views.index),
    path('posts/', views.post_list),  #주석 해제
    # path('posts/new', views.post_create),
    # path('posts/', views.post_detail),
    # path('posts//edit', views.post_update),
    # path('posts//delete', views.post_delete),
]

6.2 views.py 작성

로컬호스트:8000/posts/ 경로로 접속 시 매칭되는 views의 post_list 함수를 작성한다.

from django.shortcuts import render

# Create your views here.

def post_list(request):
    return render(request, 'posts/post_list.html')

post_list 함수는 요청이 들어오면 posts 앱 디렉토리의 post_list.html 템플릿을 렌더한다.

6.3 post_list.html 템플릿 작성

6.3.1 templates 디렉토리 생성

먼저 templates 디렉토리를 생성한다. templates과 정적 파일은 샌드위치 구조의 디렉토리를 생성해야 한다.

6.3.2 base.html 템플릿 생성

자주 사용되며 변경되지 않는 내용은 부모 템플릿을 통해 상속받도록 temlpates/posts에 base.html을 생성하고 작성한다.





    
        
        
        Dear :: Daily Events and Affective Reactions
    
    
        {% block post_container %}  
          {% endblock post_container %}

상속받지 않는 부분은 block 영역을 지정하고 post_container로 명명한다.

6.3.3 post_list.html 템플릿 생성

base.html을 상속받는 post_list.html을 생성하고 내용을 작성한다.

{% extends "./base.html" %}  

{% block post_container %}  
    글 목록 페이지입니다.
{% endblock post_container %}

base.html을 상속받는 extends 템플릿 태그를 작성하고, container 블록에 <h1> 태그를 입력한다.

개발 서버를 실행하고 접속하면 다음과 같이 나타난다.

6.4 view에 데이터를 불러오는 로직 추가

post_list 함수에 Post 모델을 통해 데이터를 가져오는 로직을 추가한다.

# views.py

from django.shortcuts import render
from .models import Post

# Create your views here.

def post_list(request):
    posts = Post.objects.all()
    context = {"posts" : posts}
    return render(request, 'posts/post_list.html', context=context)

6.4.1 각 코드의 의미

현재 디렉토리의 models 파일에서 Post 모델을 불러온다.

from .models import Post

posts 변수에 Post 모델의 모든 데이터를 불러오고, context 변수에 사전형으로 담아서 post_list.html 템플릿을 렌더할 때 함께 전달한다.

def post_list(request):
    posts = Post.objects.all()
    context = {"posts" : posts}
    return render(request, 'posts/post_list.html', context=context)

6.5 post_list 템플릿 수정

view로부터 context로 전달받은 데이터를 호출할 수 있도록 템플릿 태그를 사용해 템플릿을 수정한다.



{% extends "./base.html" %}

{% block post_container %}
    글 목록 페이지입니다.
    
        {% for post in posts %}
            
        {% endfor %}

    
        
            제목
            작성일
            수정일
        

                {{post.title}}
                {{post.dt_created}}
                {{post.dt_modified}}
            
{% endblock post_container %}

각 게시글이 쉽게 구분될 수 있도록 테이블 태그를 사용했다.

6.5.1 각 코드의 의미

for 템플릿 태그를 사용해 사전형으로 전달받은 데이터를 post 이름으로 안쪽 속성에 접근해 title, de_created, dt_modified를 각 <td> 태그에 작성하는 것을 반복한다.

{% for post in posts %}
    
        {{post.title}}
        {{post.dt_created}}
        {{post.dt_modified}}
    
{% endfor %}

6.5.2 결과

개발 서버를 실행하고 접속해보면 아래와 같이 호출된다.

7. 포스트 상세 페이지 만들기

7.1 url 패턴 설정

기존에 작성한 urls.py에서 포스트 상세 페이지에 대한 url 패턴을 주석해제 한다.

#posts/urls.py

from django.urls import path
from . import views

urlpatterns = [
    # path('', views.index),
    path('posts/', views.post_list),
    # path('posts/new', views.post_create),
    path('posts/', views.post_detail),  #주석 해제
    # path('posts//edit', views.post_update),
    # path('posts//delete', views.post_delete),
]

7.2 post_detail 뷰 작성

post_detail 뷰를 작성한다.

#posts/views.py

from django.shortcuts import render
from .models import Post

# Create your views here.

def post_list(request):
    posts = Post.objects.all()
    context = {"posts" : posts}
    return render(request, 'posts/post_list.html', context=context)


def post_detail(request, post_id):  #작성
    post = Post.objects.get(id=post_id)
    context = {"post": post}
    return render(request, 'posts/post_detail.html', context=context)

7.2.1 각 코드의 의미

post_detail 함수는 request와 post_id를 파라미터로 받는다. post_id는 posts/{url}인 경우 {url}을 정수로 보고 post_id라는 이름으로 넘겨받는 것으로 url 패턴에서 정의했다.

def post_detail(request, post_id):

post 변수에 Post 모델에서 post_id와 일치하는 값의 id를 지닌 데이터를 지정하고 context에 사전형으로 지정한다.

    post = Post.objects.get(id=post_id)
    context = {"post": post}

context와 post_detail.html 템플릿을 렌더해 반환한다.

    return render(request, 'posts/post_detail.html', context)

7.3 post_detail.html 템플릿 생성

post_detail.html 파일을 생성하고 작성한다.


{% extends "./base.html" %}

{% block post_container %}
{{post.title}}
작성일: {{post.dt_created}}

{{post.content}}

{% endblock post_container %}

7.3.1 각 코드의 의미

먼저 부모 템플릿을 상속받는 extends 템플릿 태그를 작성한다.

{% extends "./base.html" %}

부모 템플릿을 상속받지 않는 post_container 블록 영역을 추가한다.

{% block post_container %}
{% endblock post_container %}

템플릿 변수를 사용해 view로 부터 전달받은 post의 안쪽 속성에 접근한다.

{% block post_container %}
{{post.title}}
작성일: {{post.dt_created}}

{{post.content}}

{% endblock post_container %}

7.3.2 결과

개발 서버를 실행하고 posts/3 으로 접속해보면 아래와 같이 출력된다.

7.3.3 줄바꿈

그런데 문제가 있다. 생성한 데이터의 내용 중 엔터가 줄바꿈으로 인식되지 않는다.

그 이유는 장고에서는 엔터를 \n로 저장하지만 html에서는 태그로 저장하기 때문이다. 따라서 \n을 로 변경하는 작업이 필요하다.

post_detail.html 템플릿에서 post.content 변수에 linebreaksbr 템플릿 필터를 작성하면 된다.


{% extends "./base.html" %}
>
{% block post_container %}
{{post.title}}
작성일: {{post.dt_created}}

{{post.content|linebreaksbr}}
  

{% endblock post_container %}

작성하면 아래와 같이 장고의 \n 이 html의 로 변경된 것을 확인할 수 있다.

8. 목록 페이지와 상세 페이지 연결

포스트 목록 페이지와 포스트 상세 페이지를 만들었다. 현재는 포스트 상세 페이지로 이동하려면 posts/{url}을 통해 url을 직접 입력해 이동하는 방법만 있다. 포스트 목록 페이지와 상세 페이지를 연결해보자.

8.1 목록 페이지에서 상세 페이지로 연결

post_list.html 템플릿에서 포스트 제목에 태그를 추가한다.


{% extends "./base.html" %}

{% block post_container %}
    글 목록 페이지입니다.
    
        {% for post in posts %}
            
        {% endfor %}

    
        
            제목
            작성일
            수정일
        

                {{post.title}}
                {{post.dt_created}}
                {{post.dt_modified}}
            
{% endblock post_container %}

8.1.1 각 코드의 의미

태그 안에 태그가 있고 태그의 경로는 posts/{{post.id}}이며 대체 텍스트는 {{post.title}} 이다.

{{post.title}}

포스트 목록 페이지를 렌더할 때 url로 부터 posts/{url}의 {url}을 정수로 보고 post_id로 전달받고 view는 post_id를 이용해 각각의 포스트의 title, dt_created, de_modified 데이터에 접근해 출력할 수 있다.

따라서 post.id로 각 포스트의 id 데이터에 접근할 수 있고, 이를 통해 태그의 경로를 posts/{각 포스트의 id}로 지정해 제목을 클릭하면 각 포스트의 상세 페이지로 연결할 수 있다.

8.1.2 결과

포스트 목록 페이지에서 포스트 제목을 클릭하면

posts/{포스트의 id}로 이동되며

포스트의 상세 페이지를 확인할 수 있다.

8.2 상세 페이지에서 목록 페이지로 연결

post_detail.html 템플릿에 태그를 추가한다.



{% extends "./base.html" %}

{% block post_container %}
    {{post.title}}
    작성일: {{post.dt_created}}
    
    {{post.content|linebreaksbr}}
    
    돌아가기  
{% endblock post_container %}

태그에 /posts/ 경로를 입력하면 클릭 시 포스트 목록 페이지로 이동한다.

9. url에 이름 붙이기

목록 페이지에서 상세 페이지로 이동하는 url은 /posts/{{post.id}} 로 정의되어 있고, 상세 페이지에서 목록 페이지로 이동하는 url은 /posts/ 로 정의되어 있다.

문제는 url의 구조 또는 url 패턴이 변경되는 경우, 많은 수정이 필요하다는 것이다. 이번에는 하드코딩으로 인한 유지보수의 어려움을 해결하기 위해 url에 이름을 붙인다.

9.1 url 이름 붙이기

urls.py 에서 url 패턴을 살펴보자

#posts/urls.py

from django.urls import path
from . import views

urlpatterns = [
    # path('', views.index),
    path('posts/', views.post_list),
    # path('posts/new/', views.post_create),
    path('posts//', views.post_detail),
    # path('posts//edit/', views.post_update),
    # path('posts//delete/', views.post_delete),
]

name 속성을 추가해 각 url에 이름을 붙여보자.

#posts/urls.py

from django.urls import path
from . import views
from django.urls import path
from . import views

urlpatterns = [
    # path('', views.index),
    path('posts/', views.post_list, name="post-list"),  #name 속성 추가
    # path('posts/new/', views.post_create),
    path('posts//', views.post_detail, name="post-detail"),  # name 속성 추가
    # path('posts//edit/', views.post_update),
    # path('posts//delete/', views.post_delete),
]

9.2 하드코딩된 부분 수정

하드코딩된 url 경로를 템플릿 태그 {% url {url name} {인자} %}를 이용해 수정한다.

9.2.1 post_list.html 템플릿 수정

기존 태그에서는 포스트 상세 페이지 경로를 /posts/{{post.id}}로 설정했다.

템플릿 태그 url에 포스트 상세 페이지의 url name을 경로로 입력한 뒤, 한 칸 띄어서 post.id 인자를 넘겨준다.


{% extends "./base.html" %}

{% block post_container %}
    글 목록 페이지입니다.
    
        {% for post in posts %}
            
        {% endfor %}

    
        
            제목
            작성일
            수정일
        

                {{post.title}}   
                {{post.dt_created}}
                {{post.dt_modified}}
            
{% endblock post_container %}

9.2.2 post_detail.html 템플릿 수정

기존 태그에서는 포스트 목록 경로를 /posts/ 로 설정했다.

템플릿 태그 url에 포스트 목록 페이지의 url name을 경로로 입력한다.



{% extends "./base.html" %}

{% block post_container %}
    {{post.title}}
    작성일: {{post.dt_created}}
    
    {{post.content|linebreaksbr}}
    
    돌아가기  
{% endblock post_container %}

9.2.3 결과

기존에 하드코딩된 방식과 똑같이 작동한다. 추후 url이 변경되는 경우 하드코딩된 방식은 연관된 모든 파일을 수정해야 하지만, url name 속성을 입력한 방식은 연관된 파일을 수정하지 않아도 된다.

10. 디자인 입히기

html과 css를 직접 작성하지 않고, 다른 사람이 작성한 템플릿을 프로젝트에 적용하는 방법을 알아본다.

10.1 부모 템플릿 확인

base.html은 다음과 같이 작성되어 있다.



{% load static %}



    DEAR :: Daily Events and Affective Reactions
    
    {% block css %}
    {% endblock css %}
    


    
        
            
                
                    
                
            
            {% block post_header %}
            {% endblock post_header %}
        
        {% block logo_text %}
        {% endblock logo_text %}
        
            
                {% block content %}
                {% endblock content %}
            
        
        
            
                Costory

10.1.1 block 영역

부모 템플릿의 block 영역은 총 4개로 구분된다.

태그 안에 작성된 block css 는 자식 템플릿 별로 다른 css 파일을 적용하기 위한 영역이다.

{% block css %}
{% endblock css %}

태그 안에 작성된 block header 은 포스트 상세 페이지의 제목을 입력하기 위한 영역이다.

{% block post_header %}
{% endblock post_header %}

태그 안에 작성된 block logo_text 는 포스트 목록 페이지의 상단 로고를 작성하기 위한 영역이다.

{% block logo_text %}
{% endblock logo_text %}

태그 안에 작성된 block content 는 포스트 목록 페이지의 각 포스트를 보여주기 위한 영역이다.

{% block content %}
{% endblock content %}

10.2 부모 템플릿 수정

부모 템플릿의 상단 로고를 클릭하면 이동하는 url이 비어있다. 하드코딩이 아닌, url name 속성을 입력한다. dear의 메인페이지는 포스트 목록 페이지니까 url 템플릿 태그에 포스트 목록 페이지의 name 속성인 post-list를 입력한다.



{% load static %}



    DEAR :: Daily Events and Affective Reactions
    
    {% block css %}
    {% endblock css %}
    


    
        
            
                
                      
                
            
            {% block post_header %}
            {% endblock post_header %}
        
        {% block logo_text %}
        {% endblock logo_text %}
        
            
                {% block content %}
                {% endblock content %}
            
        
        
            
                Costory

10.3 post_list.html 확인

post_list.html 은 다음과 같이 작성되어 있다.



{% block css %}
    
{% endblock css %}

{% block logo_text %}
    
        
            
        
    
{% endblock logo_text %}


{% block content %}
    

    
{% endblock content %}

10.4 post_list.html 수정

우선 부모 템플릿을 상속받는 템플릿 태그와 정적파일을 불러오는 템플릿 태그를 작성한다.



{% extends "./base.html" %}  
{% load static %}  

{% block css %}
    
{% endblock css %}

{% block logo_text %}
    
        
            
        
    
{% endblock logo_text %}


{% block content %}
    

    
{% endblock content %}

다음은 하드 코딩된 css 경로를 정적파일 경로로 수정한다.



{% extends "./base.html" %}  
{% load static %}  

{% block css %}
      
{% endblock css %}

{% block logo_text %}
    
        
            
        
    
{% endblock logo_text %}


{% block content %}
    

    
{% endblock content %}

다음은 block content 영역이다. 여기에는 각 포스트의 제목, 작성일, 본문의 일부를 표기해야 한다. css를 반영할 수 있는 class를 포함한 코드를 추가하면 다음과 같다.



{% extends "./base.html" %}
{% load static %}

{% block css %}
    
{% endblock css %}

{% block logo_text %}
    
        
            
        
    
{% endblock logo_text %}


{% block content %}
    
          
            [B] 글 목록에서 보여질 제목
            [C] 글 목록에서 보여질 작성일
            [D] 글 목록에서 보여질 본문 100자
        
    
{% endblock content %}

각 포스트는 클릭 시 해당 포스트의 상세 페이지로 이동하는 기능을 해야 하니, 태그로 감싼다.

우리는 이전 과정에서 for 문을 사용해 posts에 담긴 각각의 게시글을 post로 생성했다. 이를 변경된 디자인 템플릿에도 적용될 수 있도록 작성한다.



{% extends "./base.html" %}
{% load static %}

{% block css %}
    
{% endblock css %}

{% block logo_text %}
    
        
            
        
    
{% endblock logo_text %}


{% block content %}
    
        {% for post in posts %}
            
                {{post.title}}
                {{post.dt_created}}
                {{post.content}}
            
        {% endfor %}
    
{% endblock content %}

10.5 post_detail.html 수정

이전 과정과 크게 다르지 않다. 부모 템플릿을 상속받는 템플릿 태그와 정적 파일을 불러오는 템플릿 태그를 작성한다.




{% extends "./base.html" %}
{% load static %}

css를 불러오는 css 블럭을 작성한다.




{% extends "./base.html" %}
{% load static %}

{% block css %}
    
{% endblock css %}

post_header 블럭을 작성한다.




{% extends "./base.html" %}
{% load static %}

{% block css %}
    
{% endblock css %}

{% block post_header %}
    
        {{post.title}}
        {{post.dt_created}}
    
{% endblock post_header %}

content 블럭을 작성한다.




{% extends "./base.html" %}
{% load static %}

{% block css %}
    
{% endblock css %}

{% block post_header %}
    
        {{post.title}}
        {{post.dt_created}}
    
{% endblock post_header %}

10.5 결과

포스트 목록 페이지는 다음과 같이 출력된다.

포스트 상세 페이지는 다음과 같이 출력된다.

11. 포스트 작성 페이지

포스트를 작성하고 저장하는 페이지를 만든다.

11.1 form.py 생성 및 작성

포스트 작성 페이지를 만들기 위해 posts 앱 디렉토리에 forms.py 파일을 생성한다.

장고의 forms 모듈을 불러온다.

#forms.py

from django import forms

PostForm 클래스를 만들고 forms의 Form 클래스를 부모클래스로 두어 상속받는다.

from django import forms

class PostForm(forms.form):

PostForm 클래스의 내용을 입력한다.

from django import forms

class PostForm(forms.form):
    title = forms.CharField(max_length=50, label="제목")
    content = forms.CharField(label="내용", widget=forms.Textarea)

기본적으로 폼 클래스는 모델 클래스와 작성 방식이 유사하다. 하나하나 살펴보자.

title 필드는 forms 모듈의 CharField이며 최대 길이는 50이고 필드 이름은 제목이다.

title = forms.CharField(max_length=50, label="제목")

content 필드는 forms 모듈의 CharField 이며 필드 이름 은 내용이다. 위젯 스타일은 forms 모듈의 Textarea로 설정했다.

content = forms.CharField(label="내용", widget=forms.Textarea)

Charfield는 기본적으로 한 줄 입력의 위젯을 제공하는데 Textarea 위젯을 지정하면 여러 줄 입력의 위젯으로 변경된다.

11.2 url 패턴 주석 해제

포스트 작성 페이지의 url 주석을 해제하고 url name 을 입력한다.

#urls.py

from django.urls import path
from . import views

urlpatterns = [
    # path('', views.index),
    path('posts/', views.post_list, name="post-list"),
    path('posts/new/', views.post_create, name="post-create"),  #수정
    path('posts//', views.post_detail, name="post-detail"),
    # path('posts//edit/', views.post_update),
    # path('posts//delete/', views.post_delete),
]

11.3 post_create 뷰 작성

url 경로와 매칭되는 view 함수를 작성한다.

생성한 forms 파일의 PostForm 클래스를 불러온다.

#views.py

from django.shortcuts import render
from .models import Post
from .forms import PostForm  #PostForm 클래스 불러오기

# Create your views here.

def post_list(request):
    posts = Post.objects.all()
    context = {"posts" : posts}
    return render(request, 'posts/post_list.html', context=context)


def post_detail(request, post_id):
    post = Post.objects.get(id=post_id)
    context = {"post": post}
    return render(request, 'posts/post_detail.html', context=context)

post_create 함수를 작성한다.

#views.py

from django.shortcuts import render
from .models import Post
from .forms import PostForm

# Create your views here.

def post_list(request):
    posts = Post.objects.all()
    context = {"posts" : posts}
    return render(request, 'posts/post_list.html', context=context)


def post_detail(request, post_id):
    post = Post.objects.get(id=post_id)
    context = {"post": post}
    return render(request, 'posts/post_detail.html', context=context)

def post_create(request):  #작성
    post_form = PostForm()
    context = {"post_form": post_form}
    return render(request, 'posts/post_form.html', context=context)

11.3.1 각 코드의 의미

post_form 변수에 PostForm을 빈 양식으로 지정한다.

posts_form = PostForm()

context 변수에 post_form 키와 post_form 밸류를 쌍으로 저장한다.

context = {"post_form": post_form}

context 변수를 context 인자로 담아서 posts/post_form.html 페이지를 렌더한다.

11.4 post_form.html 템플릿 생성

post_form.html 템플릿을 생성하고 내용을 작성한다.




    {{post_form}}

Post_Form 클래스를 만들었고 views의 post_create 함수에서 이를 템플릿으로 전달했으니
태그 안에 템플릿 변수인 {{post_form}}을 입력하면 폼 형식이 렌더된다. 추가적으로 전송 버튼만 태그로 작성한다.

결과는 다음과 같다.

{{post_form}} 템플릿 변수에 .as_p를 입력하면
태그의 형태로 변환된다.

이 밖에도 리스트 형태(as_ul), 테이블 형태(as_table)도 가능하다. 본 프로젝트는 미리 작성된 css 스타일을 적용하기 위해 리스트 형태로 변환한다.




    {{post_form.as_ul}}

다음은
태그의 속성을 작성한다. method 속성은 post로 작성하고 action 속성은 작성하지 않는다.



  
    {{post_form.as_ul}}

이렇게 하면 action 속성을 작성하지 않았기 때문에 post 방식으로 현재 url로 데이터를 전송한다.

다음으로는 csrf_token 템플릿 태그를 추가한다. 이 템플릿 태그는 교차 사이트 위조 검증으로 <요청하지 않은 요청>을 마치 <요청한 것 처럼 위조>하는 것을 방지하는 기술이다.



{% csrf_token %} 
    {{post_form.as_ul}}

11.5 view 작성

뷰를 수정해야하는데, 기존에 작성된 뷰를 살펴보면 다음과 같다.

#views.py

def post_create(request):
    post_form = PostForm()
    context = {"post_form": post_form}
    return render(request, 'posts/post_form.html', context=context)

우리가 해야할 것은 두 가지다.

하나는 posts/new 로 처음 접속 했을 때는 폼을 띄우는 것이고,

다른 하나는 posts/new 에서 데이터를 입력하고 전송 버튼을 눌렀을 때 입력된 데이터로 새 게시글을 저장한 다음, 해당 게시글의 상세 페이지로 이동하는 것이다.

이는 if 문과 else 문으로 구분해서 작성할 수 있다. 작성된 코드는 다음과 같다.

#views.py

from django.shortcuts import render, redirect
from .models import Post
from .forms import PostForm

# Create your views here.

def post_list(request):
    posts = Post.objects.all()
    context = {"posts" : posts}
    return render(request, 'posts/post_list.html', context=context)


def post_detail(request, post_id):
    post = Post.objects.get(id=post_id)
    context = {"post": post}
    return render(request, 'posts/post_detail.html', context=context)

def post_create(request):
    if request.method =="POST":
        title = request.POST["title"]
        content = request.POST["content"]
        new_post = Post(
            title = title,
            content = content
        )
        new_post.save()
        return redirect("post-detail", post_id=new_post.id)
    else:
        post_form = PostForm()
        context = {"post_form": post_form}
        return render(request, 'posts/post_form.html', context=context)

우리는 여기서 post_create 함수만 살펴본다.

#views.py > post_create

def post_create(request):
    if request.method =="POST":
        title = request.POST["title"]
        content = request.POST["content"]
        new_post = Post(
            title = title,
            content = content
        )
        new_post.save()
        return redirect("post-detail", post_id=new_post.id)
    else:
        post_form = PostForm()
        context = {"post_form": post_form}
        return render(request, 'posts/post_form.html', context=context)

우선 render 함수 외에 redirect 함수를 사용하기 때문에 redirect 함수를 불러온다.

from django.shortcuts import render, redirect

11.5.1 if문

먼저 if문으로 작성된 코드를 살펴본다.

if request.method =="POST":
        title = request.POST["title"]
        content = request.POST["content"]
        new_post = Post(
            title = title,
            content = content
        )
        new_post.save()
        return redirect("post-detail", post_id=new_post.id)

만약 요청 방식이 POST라면:

if request.method =="POST":

변수 title에 POST 요청이 담고 있는 데이터 중 키를 title로 하는 값을 지정한다.

title = request.POST["title"]

변수 content에 POST 요청이 담고 있는 데이터 중 키를 content로 하는 값을 지정한다.

content = request.POST["content"]

변수 new_post에 Post 모델을 사용해 title 필드에는 변수 title에 저장한 값을 넣고, content 필드에는 변수 content에 저장한 값을 넣는다.

new_post = Post(
            title = title,
            content = content
        )

new_post를 데이터베이스에 저장한다.

new_post.save()

그리고 redirect 함수를 사용해 post-detail(상세 페이지) url로 이동한다. 그런데 post-detail(상세 페이지)는 를 필요로 하니, post_id에 방금 생성한 new_post의 id를 전달한다.

return redirect("post-detail", post_id=new_post.id)

간단히 설명하면, posts/new에 접속해 폼에 데이터를 입력하고 전송 버튼을 누르면 입력된 데이터로 게시글을 생성하고, 해당 게시글의 상세 페이지로 이동하는 로직이다.

11.5.2 else문

else문으로 작성된 코드를 살펴본다.

else:
        post_form = PostForm()
        context = {"post_form": post_form}
        return render(request, 'posts/post_form.html', context=context)

만약 그렇지 않으면 (여기서는 요청 방식이 POST가 아니라면, 즉 요청 방식이 GET이라면)

else:

변수 post_form에 PostForm 폼을 지정한다.

post_form = PostForm()

그리고 변수 context에 post_form을 지정한다.

context = {"post_form": post_form}

렌더 함수를 사용해 posts/post_form.html을 렌더하고, 파라미터 context의 인자로 변수 context를 전달한다.

간단히 설명하면, posts/new url에 처음 접속(GET)하면 forms.py의 PostForm 클래스를 포함하는 게시글 작성 페이지로 이동하는 로직이다.

11.5 글쓰기 버튼 생성

form을 통해 게시글 작성 페이지를 만들었으니, 게시글 목록 페이지에서 글쓰기 버튼을 추가한다.

post_list.html의 content 블럭에 태그를 추가한다.



{% extends "./base.html" %}
{% load static %}

{% block css %}
    
{% endblock css %}

{% block logo_text %}
    
        
            
        
    
{% endblock logo_text %}


{% block content %}
    
        기록하기  
    
    
        {% for post in posts %}
            
                {{post.title}}
                {{post.dt_created}}
                {{post.content}}
            
        {% endfor %}
    
{% endblock content %}

btn_post
태그로 감싼 이유는 css 파일을 적용하기 위함이다.

12. 포스트 작성 페이지 (모델 폼)

#11. 포스트 작성 페이지에서 폼을 활용해 사용자가 입력한 데이터를 기반으로 새로운 게시글을 생성하는 기능을 구현했다.

이번에는 장고의 모델 폼 기능을 활용해 폼을 더욱 간편하게 만드는 방법을 알아본다.

12.1 forms.py 수정

기존에 작성된 폼은 다음과 같다.

#forms.py

from django import forms

class PostForm(forms.Form):
    title = forms.CharField(max_length=50, label="제목")
    content = forms.CharField(label="내용", widget=forms.Textarea)

모델 폼을 활용하기 위한 코드는 다음과 같다.

#forms.py

from django import forms
from .models import Post

class PostForm(forms.ModelForm):
    class Meta:
        model = Post
        fields = ["title", "content"]

모델 폼은 모델을 기반으로 폼을 간편하게 생성할 수 있는 기능이다.

먼저 모델을 불러와야 한다.

from .models import Post

forms.ModelForm 클래스를 상속받는 PostForm 클래스를 생성한다.

class PostForm(forms.ModelForm):

Post 모델을 참고해 title 필드와 content 필드를 입력받는 폼을 생성한다.

class Meta:
    model = Post  #Post 모델을 참고
    fields = ["title", "content"]  #폼을 통해 입력받을 필드를 추가

만약 필드가 너무 많아 일일이 입력하기가 힘들다면 모든 필드를 추가하는 방법이 있다.

    fields = "__all__"

12.2 views.py 수정

기존에 작성한 post_create 함수를 살펴본다.

def post_create(request):
    if request.method =="POST":
        title = request.POST["title"]
        content = request.POST["content"]
        new_post = Post(
            title = title,
            content = content
        )
        new_post.save()
        return redirect("post-detail", post_id=new_post.id)
    else:
        post_form = PostForm()
        context = {"post_form": post_form}
        return render(request, 'posts/post_form.html', context=context)

if문을 모델폼에 맞게 변경한다.

def post_create(request):
    if request.method =="POST":
        post_form = PostForm(request.POST)
        new_post = post_form.save()
        return redirect("post-detail", post_id=new_post.id)

12.2.1 각 코드의 의미

변경된 코드의 의미는 다음과 같다.

만약 요청 방식이 POST라면

    if request.method =="POST":

요청에 포함되어 있는 데이터(폼에 입력되고 전송된)를 PostForm과 바인딩하고 변수 post_form에 지정한다.

        post_form = PostForm(request.POST)

변수 post_form에 지정된 바운드폼을 데이터베이스에 저장한 뒤, new_post에 지정한다.

        new_post = post_form.save()

new_post의 상세 페이지로 이동한다.

        return redirect("post-detail", post_id=new_post.id)

앞으로는 더 간단한 방법인 모델 폼을 사용하도록 하자.

13. 유효성 검증

이번에는 모델폼으로 작성하는 데이터의 유효성을 검증하는 방법을 알아본다.

유효성을 검증하는 방법은 두 가지가 있다. 모델 필드 또는 폼 필드를 통한 유효성 검증 방법과 Validator를 통한 유효성 검증 방법이 있다.

13.1 필드를 통한 유효성 검증

우리는 모델 폼을 사용하기 때문에 폼 필드가 아닌, 모델 필드를 통해 유효성을 검증하는 방법을 알아본다.

13.1.1 models.py 수정

만약, 게시글의 제목은 중복될 수 없음 이라는 정책이 있다면, 우리는 게시글 작성 페이지에서 게시글을 생성하기 전, 제목에 입력된 데이터가 기존에 생성된 게시글의 제목과 중복되지 않는지 유효성을 검사해야 한다.

그러기 위해서 Post 모델의 title 필드에 unique 옵션을 추가한다.

from django.db import models

# Create your models here.

class Post(models.Model):
    title = models.CharField(max_length=50, unique=True)
    content = models.TextField()
    dt_created = models.DateTimeField(verbose_name="Date Created", auto_now_add=True)
    dt_modified = models.DateTimeField(verbose_name="Date Modified", auto_now=True)

    def __str__(self):
        return self.title

중복된 제목으로 인해 유효성 검증에 실패하면 유저에게 보여줄 에러메세지를 변경하는 error_messages 옵션을 추가한다.

from django.db import models

# Create your models here.

class Post(models.Model):
    title = models.CharField(max_length=50, unique=True, error_messages={"unique":"이미 같은 제목의 게시글이 존재합니다"})
    content = models.TextField()
    dt_created = models.DateTimeField(verbose_name="Date Created", auto_now_add=True)
    dt_modified = models.DateTimeField(verbose_name="Date Modified", auto_now=True)

    def __str__(self):
        return self.title

13.1.2 views.py 수정

post_create 뷰에서 유효성 검증을 통과한 경우와 그렇지 않은 경우에 따른 로직을 구분한다.

#views.py > post_create

def post_create(request):
    if request.method =="POST":
        post_form = PostForm(request.POST)
        if post_form.is_valid():
            new_post = post_form.save()
            return redirect("post-detail", post_id=new_post.id)
        else:
            context = {"post_form": post_form}
    else:
        post_form = PostForm()
        context = {"post_form": post_form}
    return render(request, 'posts/post_form.html', context=context)

변경된 코드의 의미는 다음과 같다.

만약 요청 방식이 POST 라면

    if request.method =="POST":

PostForm 폼과 요청이 담고있는 데이터를 바인딩 하고 변수 post_form에 지정한다.

        post_form = PostForm(request.POST)

만약 post_form이 유효성 검증에 통과하면

        if post_form.is_valid():

post_form을 기반으로 게시글을 생성하고 변수 new_post에 지정한다.

            new_post = post_form.save()

그리고 해당 게시글의 상세 페이지로 이동한다.

            return redirect("post-detail", post_id=new_post.id)

만약 post_form이 유효성 검증에 실패하면

        else:

변수 context에 post_form을 지정한다.

            context = {"post_form": post_form}

이때, else문과 if문 밖으로 이동해 마지막 return문으로 이동한다. 결과적으로는 post_form(입력한 데이터)를 유지한 채로 post_form.html을 다시 렌더한다.

만약 요청 방식이 POST가 아니라면,

    else:

변수 post_form에 비어있는 Post_form 폼을 지정한다.

        post_form = PostForm()

변수 context에 post_form을 지정한다.

        context = {"post_form": post_form}

context에 담긴 데이터를 가지고 post_form.html을 렌더한다.

    return render(request, 'posts/post_form.html', context=context)

13.2 bulit-in validator를 통한 유효성 검증

만약 보다 복잡한 유효성 검증이 필요한 경우, 장고에서 제공하는 유효성 검증인 validator를 통한 유효성 검증을 방법을 선택할 수 있다.

validator는 장고에서 제공하는 bulit-in validator와 직접 구현한 validator가 있는데, 여기서는 전자를 사용할 것이다.

13.2.1 django built-in validators

[django built-in validators] (https://docs.djangoproject.com/en/5.0/ref/validators/)에 접속하면 다양한 밸리데이터를 찾을 수 있다.

13.2.2 models.py 수정

게시글 내용에 최소길이제한 유효성 검증을 적용해본다.

djnago.core.validators 모듈의 최소길이제한 클래스를 불러온 뒤, content 필드에 적용할 최소길이와 에러메세지를 입력한다.

밸리데이터를 추가하기 위해서는 리스트 형식으로 작성해야 한다.

# models.py

from django.db import models
from django.core.validators import MinLengthValidator  #최소길이제한 클래스

# Create your models here.

class Post(models.Model):
    title = models.CharField(max_length=50, unique=True, error_messages={"unique":"이미 같은 제목의 게시글이 존재합니다"})
    content = models.TextField(validators=[MinLengthValidator(10, "10자 이상 입력해주세요")])  #입력
    dt_created = models.DateTimeField(verbose_name="Date Created", auto_now_add=True)
    dt_modified = models.DateTimeField(verbose_name="Date Modified", auto_now=True)

    def __str__(self):
        return self.title

개발서버를 실행한 결과 아래와 같이 잘 적용되는 것을 확인할 수 있다.

13.3 직접 만든 validator

이번에는 validator를 직접 만드는 방법을 알아본다.

13.3.1 validators.py 생성 및 작성

validators.py을 생성하고 ValidationError 객체를 불러온 뒤, 함수를 작성한다.

#validators.py

from django.core.exceptions import ValidationError


def validate_symbols(value):
    if ("@" in value) or ("#" in value):
        raise ValidationError("'@'와 '#'은 포함될 수 없습니다.", code="symbol_error")

ValidationError는 유효성 검증 에러를 일으키는 객체다.

from django.core.exceptions import ValidationError

validate_symbols 함수는 if문을 사용해 @ 또는 #이 포함되면 유효성검증 에러를 발생시킨다.

def validate_symbols(value):
    if ("@" in value) or ("#" in value):
        raise ValidationError("'@'와 '#'은 포함될 수 없습니다.", code="symbol_error")

13.3.2 models.py 수정

작성한 validate_symbols를 Post 모델의 content 필드에 적용한다.

#models.py

from django.db import models
from django.core.validators import MinLengthValidator
from .validators import validate_symbols  #밸리데이터 불러오기

# Create your models here.

class Post(models.Model):
    title = models.CharField(max_length=50, unique=True, error_messages={"unique":"이미 같은 제목의 게시글이 존재합니다"})
    content = models.TextField(validators=[MinLengthValidator(10, "10자 이상 입력해주세요"),
                                           validate_symbols])  #밸리데이터 적용
    dt_created = models.DateTimeField(verbose_name="Date Created", auto_now_add=True)
    dt_modified = models.DateTimeField(verbose_name="Date Modified", auto_now=True)

    def __str__(self):
        return self.title

개발서버를 실행한 결과 잘 작동되는 것을 확인할 수 있다.

14. 폼 구조 변경하기

지금의 폼 구조는 이쁘지가 않다. css를 적용하기 전 폼의 구조를 변경하는 방법을 알아본다.

14.1 post_form.html 템플릿 수정

현재는 PostForm 폼을 템플릿 태그 {{post_form}} 으로 일괄적으로 불러온다. 각 폼의 인풋을 별도로 불러오는 코드로 변경해 본다.



{% csrf_token %}
    제목
    {{post_form.title}}
    내용
    {{post_form.content}}

코드를 살펴보면 폼의 안쪽 속성으로 필드에 접근해서
태그로 감싼 형태로 작성했다. 결과는 아래와 같다.

좀 더 깔끔한 모습으로 변했다. 그러나 에러메세지가 호출되지 않는다. 기존에는 템플릿 태그 {{post_form}}로 폼을 일괄적으로 호출해서 에러메세지가 포함되었다. 이번에는 에러메세지도 별도로 호출하는 코드를 작성한다.



{% csrf_token %}
    제목
    {{post_form.title}}
    {% for error in post_form.title.errors %}
        {{error}}
    {% endfor %}
    내용
    {{post_form.content}}
    {% for error in post_form.content.errors %}
        {{error}}
    {% endfor %}

에러메세지가 여러 개일 수 있으니 for문을 활용해 각 필드의 에러 중, 각각의 에러를 호출한다. 에러는 .errors 로 접근할 수 있다.

개발서버를 실행한 결과 에러메세지가 잘 호출되는 것을 확인할 수 있다.

15. 폼 디자인 적용

폼 디자인을 적용하는 방법을 단계별로 알아본다.

15.1 form.css

정적파일 디렉토리에 form.css 파일을 생성하고 작성한다.

/*form.css*/

.error {
    color: red;
}

15.2 post_form.html

css를 적용하기 위해 부모 템플릿을 상속받는 템플릿 태그와 정적파일을 불러오는 템플릿 태그를 작성한다.

그리고 css 블럭 영역에 방금 생선한 form.css 파일을 적용한다.

다음으로
태그를 content 블럭 영역으로 감싼다.

마지막으로 에러메세지를 담고있는
태그에 error 클래스를 적용한다.



{% extends "./base.html" %}
{% load static %}

{% block css %}
    
{% endblock css %}

{% block content %}
    {% csrf_token %}
        제목
        {{post_form.title}}
        {% for error in post_form.title.errors %}
            {{error}}
        {% endfor %}
        내용
        {{post_form.content}}
        {% for error in post_form.content.errors %}
            {{error}}
        {% endfor %}
        
    
{% endblock content %}

결과는 아래와 같다.

15.3 인풋 디자인 적용

에러메세지의 경우 클래스를 지정해서 해당 클래스에 css를 적용할 수 있었다.

그러나 인풋의 경우 필드별로 장고가 지정한 위젯을 사용하기 때문에 장고 공식 문서에서 해당 필드의 기본 위젯이 무엇인지 확인한 뒤, 해당 위젯에 클래스를 지정한 뒤, 해당 클래스에 css를 적용해야 한다.

15.3.1 CharField의 위젯 변경

장고 공식문서를 통해 확인한 결과 CharField의 기본 위젯은 TextInput이다.

forms.py의 Meta 클래스에서 widgets은 필드를 키로 하고 값으로 위젯 이름을 입력하면, 다른 위젯을 기본 위젯으로 사용할 수 있다. 또는 지금처럼 직접 기본 위젯에 접근해야 할 때 사용할 수 있다.

#forms.py

from django import forms
from .models import Post

class PostForm(forms.ModelForm):
    class Meta:
        model = Post
        fields = ["title", "content"]
        widgets = {"title": forms.TextInput(attrs={"class": "title", "placeholder": "제목이 입력하세요",}), 
                "content": forms.Textarea(attrs={"placeholder": "내용을 입력하세요"})}

위 코드를 확인해보면 Meta 클래스에 widgets을 두고 title 필드의 위젯을 TextInput으로 지정하고 attrs로 해당 위젯의 속성에 접근해 title 클래스를 지정했다.

또한 title 필드와 content 필드의 placeholder를 지정했다.

이후 form.css 에서 title 클래스에 대한 css를 선언한다.

/*form.css*/

.error {
    color: red;
}

.title {
    width: 400px;
}

16. 폼 css 적용

이미 작성되어 있는 css를 적용하는 방법을 알아본다.

16.1 css 파일 살펴보기

전달 받은 css는 다음과 같다.

/*post_form.css*/

h1,h2,h3,p,a,ul,li{
    margin: 0;
    padding: 0;
    font-family : 'NanumMyeongjo';
    font-weight: 200;
    list-style:  none;
    text-decoration: none; 
    outline: none;
    color: black;
}
a:hover,a:active,button:hover {
    text-decoration: none;
}
html{
    position: relative;
    min-height: 100%;
    margin: 0;
}
body {
    min-height: 100%;
    margin: 0;
    padding: 0;
    background: #2b2a2e;
    -webkit-font-smoothing: antialiased;
    -moz-osx-font-smoothing: auto;
}
img {
    margin: 0;
    padding: 0;
    border: 0;
}

#nav{
    height: 60px;
}
#header{
    margin: 20px 0 20px;
}
#content{
    margin-bottom: 300px;
}
#footer{
    position: absolute;
    left: 0;
    bottom: 0;
    width: 100%;
    height: 75px;
    background: rgba(41, 41, 44, 0.7);
}
.container{
    width: 800px;
    margin: 0 auto;
}

.logo{
    width: 65%;
    min-width: 899px;
    margin: 0 auto;
    padding-top: 17px;
}
.logo img{
    width: 88px;
}
h1{
    text-align: center;
    font-size: 32px;
    letter-spacing: -2px;
    color: #fff;
}
.error{
    text-align: right;
    color: red;
    padding-right: 20px;
    padding-bottom: 20px;
}
.submit{
    margin-bottom: 27px;
    text-align: right;
}
input[type="submit"]{
    padding: 10px 43px 11px 19px; 
    font-size: 15px;
    font-family : 'NanumMyeongjo';
    color: #fff;
    border: 1px solid #5b595f;
    border-radius: 1px;
    letter-spacing: -0.35px;
    background: url(../images/pen.svg)no-repeat 89px 11px/16px;
    cursor: pointer;
}
input[type="submit"]:hover{
    color: #ccc;
    transition: all 0.2s;
}
.editor{
    background: #f9f9f9;
}
input[type="text"]{
    display: block;
    width: 100%;
    padding: 35px 33px 0 30px;
    border: none;
    font-size: 19px;
    font-family : 'NanumMyeongjo';
    background-color: transparent;
    box-sizing: border-box;
}
textarea{
    width: 100%;
    height: 500px;
    padding: 33px 33px 30px 30px;
    border: none;
    font-size: 15px;
    line-height: 1.73;
    font-family : 'NanumMyeongjo';
    background-color: transparent;
    resize: none;
    box-sizing: border-box;
}
textarea,input:focus{
    outline: none;
}
textarea::placeholder{
    color: #a9abb7;
    letter-spacing: -0.44px;
}
input::placeholder{
    color: #a9abb7;
    letter-spacing: -0.44px;
}
.btn_back a{
    display: inline-block;
    margin-top: 30px;
    padding: 10px 19px 11px;
    color: #e38917;
    font-size: 15px;
    border: 1px solid #e38917;
}
.btn_back a:hover{
    color: #f2ad56;
    transition: all .2s;
}
.footer{
    width: 65%;
    min-width: 899px;
    margin: 0 auto;
}
.footer p{
    text-align: right;
    font-size: 20px;
    line-height: 75px;
    font-weight: 800;
    letter-spacing: -0.85px;
    color: #53534f;
}

16.2 post_form.html 수정

작성된 css 적용을 위해 html 템플릿을 수정한다.



{% extends "./base.html" %}
{% load static %}

{% block css %}
      
{% endblock css %}

{% block post_header %}  
      
        글쓰기
    
{% endblock post_header %}

{% block content %}
    {% csrf_token %}
        
            
        
         
                {{post_form.title}}
                {% for error in post_form.title.errors %}
                {{error}}
                {% endfor %}
                {{post_form.content}}
                {% for error in post_form.content.errors %}
                {{error}}
                {% endfor %}
        
    
      
        목록으로  
    
{% endblock content %}

17. 포스트 수정 페이지

기존에 작성된 게시글을 수정하는 페이지를 만들어 본다. 수정 페이지는 폼 페이지에 기존에 작성된 내용을 불러오는 형태로 만들면 될 것 같다.

17.1 url 패턴 주석 해제

urls.py 에서 주석 처리된 url 패턴을 주석 해제하고 name 속성에 post-update를 작성한다.

#urls.py

from django.urls import path
from . import views

urlpatterns = [
    # path('', views.index),
    path('posts/', views.post_list, name="post-list"),
    path('posts/new/', views.post_create, name="post-create"),
    path('posts//', views.post_detail, name="post-detail"),
    path('posts//edit/', views.post_update, name="post-update"),  #주석 해제 및 name 속성 작성
    # path('posts//delete/', views.post_delete),
]

17.2 상세 페이지에서 수정하기 버튼 추가

상세 페이지에서 게시글을 수정할 수 있는 태그를 추가한다.

css 적용을 위해 두 개의
태그로 감싸고 클래스를 지정한다.

포스트의 id를 넘겨준다.



{% block content %}
    
        {{post.content|linebreaksbr}}
        수정일 {{post.dt_modified}}
    
        
            
                스토리 목록으로
            
              
                  
                    수정하기  
                
  
            
  
    
{% endblock content %}

17.3 뷰 작성

views.py에서 post_update 함수를 추가한다.

#views.py > post_update

def post_update(request, post_id):
    post = Post.objects.get(id=post_id)
    if request.method == "POST":
        post_form = PostForm(request.POST, instance=post)
        if post_form.is_valid():
            post_form.save()
            return redirect("post-detail", post_id=post.id)
    else:
        post_form = PostForm(instance=post)
    context = {"post_form": post_form}
    return render(request, "posts/post_form.html", context)

17.3.1 각 코드의 의미

post_update 함수를 생성하는데, 요청과, post_id를 인자로 받는 파라미터를 추가한다.

def post_update(request, post_id):

Post 모델에서 post_id로 전달 받은 인자와 동일한 값의 id를 지닌 데이터를 불러와 변수 post에 지정한다.

    post = Post.objects.get(id=post_id)

만약 요청 방식이 POST라면

    if request.method == "POST":

폼 PostForm에 POST에 담긴 데이터를 바인딩하고, 새 인스턴스가 아닌 post로 지정된 인스턴스에 매칭시킨 후 변수 post_form에 지정한다.

        post_form = PostForm(request.POST, instance=post)

만약 변수 post_form의 데이터가 유효성 검증을 통과하면

        if post_form.is_valid():

post_form 을 데이터 베이스에 저장한다.

            post_form.save()

상세 페이지로 이동하는데, 상세 페이지에서는 포스트의 id를 필요로 하기 때문에 post_id에 다시 post.id를 담아서 넘겨준다.

            return redirect("post-detail", post_id=post.id)

만약 요청 방식이 POST가 아니라면,

    else:

변수 post_form에 폼 PostForm을 지정하는데, 새 인스턴스가 아닌, post로 지정된 인스턴스에 매칭시킨다.

        post_form = PostForm(instance=post)

변수 context에 post_form을 지정한다.

    context = {"post_form": post_form}

요청과 context를 담아서 post_form.html 템플릿을 렌더한다.

    return render(request, "posts/post_form.html", context)

18. 포스트 삭제

포스트를 삭제하는 기능을 구현한다.

18.1 url 패턴 주석 해제

url 패턴의 주석을 해제하고 name 속성을 작성한다.

#urls.py

from django.urls import path
from . import views

urlpatterns = [
    # path('', views.index),
    path('posts/', views.post_list, name="post-list"),
    path('posts/new/', views.post_create, name="post-create"),
    path('posts//', views.post_detail, name="post-detail"),
    path('posts//edit/', views.post_update, name="post-update"),
    path('posts//delete/', views.post_delete, name="post-delete),  # 주석 해제
]

18.2 상세 페이지에서 삭제하기 버튼 추가

상세 페이지에 태그를 작성해 삭제하기 버튼을 추가한다.



{% block content %}
    
        {{post.content|linebreaksbr}}
        수정일 {{post.dt_modified}}
    
        
            
                스토리 목록으로
            
            
                
                    수정하기
                
                 
                    삭제하기
                
            
    
{% endblock content %}

18.3 뷰 작성

포스트를 삭제하는 뷰를 작성한다.

#views.py

def post_delete(request, post_id):
    post = Post.objects.get(id=post_id)
    post.delete()
    return redirect("post-list")

url로부터 전달받은 id에 해당하는 데이터를 삭제하는 코드다. 삭제 후에는 목록 페이지로 리다이렉트 한다.

19. 삭제하기 컨펌 페이지

삭제하기 버튼 클릭 시, 컨펌 없이 바로 삭제가 된다면 유저 경험 측면에서 좋지 않다. 따라서 삭제하기 컨펌 페이지를 만드는 방법을 알아본다.

19.1 삭제하기 컨펌 페이지 템플릿 작성

삭제하기 버튼을 클릭하면 이동되는 템플릿을 작성한다.



{% extends './base.html' %}
{% load static %}

{% block css %}
    
{% endblock css %}

{% block content %}

    [{{post.title}}]
    삭제하시겠습니까?
    {% csrf_token %}
        
            
            돌아가기
        
    

{% endblock content %}

19.2 삭제하기 컨펌 페이지 css 작성

css는 강의에서 전달받은 css 파일에 개인적으로 적용하고 싶은 부분을 추가했다.

/*post_confirm_delete.css*/

h1,h2,h3,p,a,ul,li{
    margin: 0;
    padding: 0;
    font-family : 'NanumMyeongjo';
    font-weight: 200;
    list-style:  none;
    text-decoration: none; 
    outline: none;
    color: black;
}
a:hover,a:active,button:hover {
    text-decoration: none;
}
html{
    position: relative;
    min-height: 100%;
    margin: 0;
}
body {
    min-height: 100%;
    margin: 0;
    padding: 0;
    background: #2b2a2e;
    -webkit-font-smoothing: antialiased;
    -moz-osx-font-smoothing: auto;
}
img {
    margin: 0;
    padding: 0;
    border: 0;
}

#nav{
    height: 60px;
}
#content{
    margin-top: 160px;
    margin-bottom: 300px;
}
#footer{
    position: absolute;
    left: 0;
    bottom: 0;
    width: 100%;
    height: 75px;
    background: rgba(41, 41, 44, 0.7);
}
.container{
    width: 800px;
    margin: 0 auto;
}

.logo{
    width: 65%;
    min-width: 899px;
    margin: 0 auto;
    padding-top: 17px;
}
.logo img{
    width: 88px;
}
.confirm{
    padding: 108px 0 124px;
    text-align: center;
    background: #fff;
}
p{
    font-size: 17px;
    color: #575362;
    letter-spacing: -0.35px;
}
p.title{
    padding-bottom: 8px;
    font-size: 20px;
    font-weight: bold;
    color: #333236;
    letter-spacing: -0.45px;
}
.confirm_btn{
    padding-top: 46px;
}
.confirm_btn ul li{
    display: inline-block;
}
.confirm_btn input{

    display: inline-block;
    padding: 10px 19px 11px;
    font-size: 15px;
    color: #f6f6f6;
    background: red;
    border: none;
}
.confirm_btn a{
    display: inline-block;
    margin-left: 18px;
    padding: 10px 19px 11px;
    font-size: 15px;
    color: #69666d;
    background: #f6f6f6;
    border: none;
}

.confirm_btn a:hover{
    color: #95929a;
    transition: all .2s;
}

.confirm_btn input:hover{
    color: red;
    background: #f6f6f6;
    transition: all .2s;
}
.footer{
    width: 65%;
    min-width: 899px;
    margin: 0 auto;
}
.footer p{
    text-align: right;
    font-size: 20px;
    line-height: 75px;
    font-weight: 800;
    letter-spacing: -0.85px;
    color: #53534f;
}

19.3 뷰 작성

기존에 작성한 post_delete 함수를 수정한다.

#views.py > post_delete

def post_delete(request, post_id):
    post = Post.objects.get(id=post_id)
    if request.method == "POST":
        post.delete()
        return redirect("post-list")
    else:
        context = {"post": post}
        return render(request, "posts/post_confirm_delete.html", context=context)

요청 방식이 POST인 경우 게시글을 삭제하고 포스트 목록 페이지로 리다이렉트 한다.

요청 방식이 GET인 경우 삭제하기 컨펌 템플릿을 렌더한다.

Django 배포 준비

Thu, 04 Jan 2024 08:22:15 GMT

장고 프로젝트를 배포하기 위해 준비해야하는 내용을 알아본다.

디버그 모드 끄기

디버그 모드를 키면 에러 발생 시 자세한 에러 내용을 페이지에 표시한다. 너무 자세한 내용이 표시되면 보안에 문제가 될 수 있으므로, 디버그 모드를 종료해야 한다.

프로젝트 구성 디렉토리로 이동해 settings.py로 이동한다.

디버그 모드를 false로 변경한다.

#settings.py

DEBUG = False  #True에서 False로 변경

허용 호스트 설정

다음으로 허용하는 호스트를 설정해야 한다.

디버그 모드와 마찬가지로 settings.py에서 설정한다.

ALLOWED_HOSTS = []는 로컬 호스트, 내 컴퓨터에서만 접속할 수 있는 환경이다

#settings.py

ALLOWED_HOSTS = ['.pythonanuwhere.com']  #파이썬 애니웨어를 통해 배포하는 경우

ALLOWED_HOSTS = []  #로컬 호스트에서만 허용하는 경우

정적파일을 한 곳으로 정리하기

마찬가지로 setting.py 에서 설정한다.

STATIC_URL 항목 하단에 아래의 코드를 입력한다.

#settings.py

STATIC_URL = '/static/'
STATIC_ROOT = os.path.join(BASE.DIR, 'static')

STATIC_ROOT = os.path.join(BASE.DIR, 'static')는 현재 파일(setting.py)의 BASE.DIR(최상위 디렉토리 ,즉 루트 디렉토리)에 static 디렉토리를 지정해 모든 정적 파일을 이 경로에 복사하겠다는 뜻이다.

모든 정적 파일을 복사할 경로를 지정한 것이기에 다음 명령어를 입력해야 모든 정적파일이 실제로 복사된다.

python manage.py collectstatic  #모든 정적파일을 지정한 디렉토리로 복사하는 명령어

배포 준비는 끝났는데...

배포 준비는 모두 끝났다. 배포는 각 호스팅 서비스에 맞춰서 진행하면 된다. 본인은 아직 모든 강의를 끝내지 않았기에 호스팅 서비스를 정하지 못했다.

제목	작성일	수정일
{{post.title}}	{{post.dt_created}}	{{post.dt_modified}}

Ethan.Devlog

플스 포탈 5G 와이파이가 잡히지 않는 문제 해결

1. 증상

2. 대처 (실패)

2.1 TP링크 공유기 구매

2.2 TP링크 와이파이 증폭기 구매

2.3 공유기 및 모뎀 초기화

2.4 플스 포탈 초기화

3. 대처(성공)

3.1 무선 공유기 로그인

3.1.1 무선 공유기 주소 찾기

3.1.2 무선 공유기 ID 및 비밀번호

유선 MAC 예시 : 1234.AB12.CD34

비밀번호 예시 : 12CD34_admin(대소문자구분)

3.1.3 와이파이 채널 변경

4. 그래도 안된다면?

rest_framework 모듈 불러오지 못하는 문제

1. 발생한 문제

2. 접근

2.1 가상환경이 적용되었는지 확인

2.2 drf가 잘 설치되어있는지 확인

2.3 vscode에서 인터프리터를 현재 가상환경으로 설정했는지 확인

3. 해결

Django allauth

1. contrib.auth와 allauth

2. 개발환경 설정

2.1 앱 등록

2.2 유저 모델 정의

2.3 유저 모델 등록

2.4 마이그레이션

2.5 admin 등록

2.6 allauth 설치

2.6.1 에러 발생

2.7 url 패턴 작성

2.8 마이그레이션

2.9 결과

3. 회원가입 후 홈페이지로 이동

3.1 구성 디렉토리 urls 변경

3.2 앱 디렉토리 urls 생성

3.3 index 뷰 생성

3.4 템플릿 생성

홈페이지

3.5 allauth 세팅 변경

4. 유저 정보 표기

4.1 유저 데이터 접근

4.2 템플릿 변경

홈페이지

4.3 로그아웃 뎁스 줄이기

5. 세션 ID

제네릭 뷰 context 기본값

1. ListView

1.1 비교

2. DetailView

2.1 비교

3. CreateView

3.1 비교

4. UpdateView

4.1 비교

5. DeleteView

5.1 비교

제네릭 뷰 DeleteView

DeleteView를 상속하는 클래스형 뷰 생성

url 패턴 변경

제네릭 뷰 UpdateView

1. UpdateView를 상속받는 클래스형 뷰 생성

1.1 기존 함수형 뷰 post_update

1.2 변경된 클래스형 뷰 PostUpdateView

1.3 url 패턴 변경

제네릭 뷰 DetailView

1. DetailView를 상속받는 클래스형 뷰 생성

1.1 기존 함수형 뷰 post_detail

1.2 변경된 클래스형 뷰 PostDetailView

1.3 url 패턴 변경

제네릭 뷰 ListView

1. ListView를 상속받은 클래스형 뷰 생성

1.1 기존 함수형 뷰 post_list

1.2 변경된 클래스형 뷰 PostListView

1.2.1 주의할 점

1.3 템플릿 수정

{{post.title}}

Django allauth