밤톨이의 개발공부

django-admin startapp restaurant

INSTALLED_APPS = [
    'django.contrib.admin',
    'django.contrib.auth',
    'django.contrib.contenttypes',
    'django.contrib.sessions',
    'django.contrib.messages',
    'django.contrib.staticfiles',
    'tweet',
    'user',
    'restaurant', #요기

# restaurant/models.py
from django.db import models


# Create your models here.

class MyTopping(models.Model):
    class Meta:
        db_table = "my_topping"

    def __str__(self):
        return self.topping_name

    topping_name = models.CharField(max_length=100)


class MyPizza(models.Model):
    class Meta:
        db_table = "my_pizza"

    def __str__(self):
        return self.pizza_name

    pizza_name = models.CharField(max_length=100)
    pizza_topping = models.ManyToManyField(MyTopping)

python manage.py makemigrations
python manage.py migrate

from django.contrib import admin
from .models import MyTopping, MyPizza

# Register your models here.

admin.site.register(MyPizza)
admin.site.register(MyTopping)

python manage.py createsuperuser

python manage.py makemigrations
python manage.py migrate

python manage.py shell

>>> from restaurant.models import MyTopping, MyPizza

#전체 피자
>>> MyPizza.objects.all()
<QuerySet [<MyPizza: 도미노>, <MyPizza: 피자헛>, <MyPizza: 파파존스>]>

# 피자를 하나씩 불러볼게요
>>> MyPizza.objects.get(pizza_name='도미노')
<MyPizza: 도미노>
>>> MyPizza.objects.get(pizza_name='피자헛')
<MyPizza: 피자헛>
>>> MyPizza.objects.get(pizza_name='파파존스')
<MyPizza: 파파존스>

# 각 피자의 토핑들을 불러볼게요
>>> MyPizza.objects.get(pizza_name='도미노').pizza_topping.all()
<QuerySet [<MyTopping: 치즈>, <MyTopping: 치킨>]>
>>> MyPizza.objects.get(pizza_name='피자헛').pizza_topping.all()
<QuerySet [<MyTopping: 치즈>, <MyTopping: 페퍼로니>, <MyTopping: 올리브>]>
>>> MyPizza.objects.get(pizza_name='파파존스').pizza_topping.all()
<QuerySet [<MyTopping: 치즈>, <MyTopping: 페퍼로니>, <MyTopping: 피망>]>

>>> from restaurant.models import MyTopping, MyPizza

#전체 토핑
>>> MyTopping.objects.all()
<QuerySet [<MyTopping: 치즈>, <MyTopping: 페퍼로니>, <MyTopping: 올리브>, <MyTopping: 치킨>, <MyTopping: 피망>]>

#각 토핑별로 출력
>>> MyTopping.objects.get(topping_name='치즈')
<MyTopping: 치즈>
>>> MyTopping.objects.get(topping_name='페퍼로니')
<MyTopping: 페퍼로니>
>>> MyTopping.objects.get(topping_name='올리브')
<MyTopping: 올리브>
>>> MyTopping.objects.get(topping_name='치킨')
<MyTopping: 치킨>
>>> MyTopping.objects.get(topping_name='피망')
<MyTopping: 피망>

# 각 토핑이 들어있는 피자를 불러오기
>>> MyTopping.objects.get(topping_name='치즈').mypizza_set.all()
<QuerySet [<MyPizza: 도미노>, <MyPizza: 피자헛>, <MyPizza: 파파존스>]>
>>> MyTopping.objects.get(topping_name='페퍼로니').mypizza_set.all()
<QuerySet [<MyPizza: 피자헛>, <MyPizza: 파파존스>]>
>>> MyTopping.objects.get(topping_name='올리브').mypizza_set.all()
<QuerySet [<MyPizza: 피자헛>]>
>>> MyTopping.objects.get(topping_name='치킨').mypizza_set.all()
<QuerySet [<MyPizza: 도미노>]>
>>> MyTopping.objects.get(topping_name='피망').mypizza_set.all()
<QuerySet [<MyPizza: 파파존스>]>

# user/models.py
from django.db import models
from django.contrib.auth.models import AbstractUser
from django.conf import settings

# Create your models here.
class UserModel(AbstractUser):

    class Meta:
        db_table = "my_user"

    bio = models.TextField(max_length=500, blank=True)
    follow = models.ManyToManyField(settings.AUTH_USER_MODEL,related_name='followee')

python manage.py makemigrations
python manage.py migrate

# user/views.py 

@login_required
def user_view(request):
    if request.method == 'GET':
        # 사용자를 불러오기, exclude와 request.user.username 를 사용해서 '로그인 한 사용자'를 제외하기
        user_list = UserModel.objects.all().exclude(username=request.user.username)
        return render(request, 'user/user_list.html', {'user_list': user_list})


@login_required
def user_follow(request, id):
    me = request.user
    click_user = UserModel.objects.get(id=id)
    if me in click_user.followee.all():
        click_user.followee.remove(request.user)
    else:
        click_user.followee.add(request.user)
    return redirect('/user')

path('user/', views.user_view, name='user-list'), 
path('user/follow/<int:id>',views.user_follow, name='user-follow')

from django.db import models 
from django.contrib.auth.models import AbstractUser # 이 줄 추가!


# Create your models here. 
class UserModel(AbstractUser): #상속시켜줘야함!

    class Meta: 
        db_table = "my_user" # 여기는 테이블 이름이에요! 꼭 기억 해 주세요!

    bio = models.TextField(max_length=500, blank=True) #필요한 테이블만 남기고 나머지는 삭제.

AUTH_USER_MODEL = 'user.UserModel'

python manage.py makemigrations  
python manage.py migrate

# user/views.py 
from django.contrib.auth import get_user_model #사용자가 있는지 검사하는 함수

# user/views.py 
def sign_up_view(request): 
    if request.method == 'GET': 
        return render(request, 'user/signup.html') 
    elif request.method == 'POST': 
        username = request.POST.get('username', None) 
        password = request.POST.get('password', None) 
        password2 = request.POST.get('password2', None) 
        bio = request.POST.get('bio', None) 
        if password != password2: 
            return render(request, 'user/signup.html') 
        else: 
            exist_user = get_user_model().objects.filter(username=username) 
            if exist_user: 
		return render(request, 'user/signup.html') # 사용자가 존재하기 때문에 사용자를 저장하지 않고 회원가입 페이지를 다시 띄움 
            else: 
                UserModel.objects.create_user(username=username, password=password, bio=bio) #이렇게 한 줄로 바뀌었다. 
                return redirect('/sign-in') # 회원가입이 완료되었으므로 로그인 페이지로 이동

# user/views.py 
from django.contrib import auth # 사용자 auth 기능

# user/views.py 
def sign_in_view(request): 
    if request.method == 'POST': 
        username = request.POST.get('username', None) 
        password = request.POST.get('password', None)

        me = auth.authenticate(request, username=username, password=password)  # 사용자 불러오기 
        if me is not None:  # 저장된 사용자의 패스워드와 입력받은 패스워드 비교 
            auth.login(request, me) 
            return HttpResponse("로그인 성공") 
        else: 
            return redirect('/sign-in')  # 로그인 실패 
    elif request.method == 'GET': 
        return render(request, 'user/signin.html')

# tweet/views.py 
from django.shortcuts import render, redirect 
# Create your views here. 
def home(request): 
    user = request.user.is_authenticated  # 사용자가 인증을 받았는지 (로그인이 되어있는지) 
    if user: 
        return redirect('/tweet') 
    else: 
        return redirect('/sign-in') 
def tweet(request): 
    if request.method == 'GET': 
        return render(request, 'tweet/home.html')

# tweet/urls.py 
from django.urls import path 
from . import views 
urlpatterns = [ 
    path('', views.home, name='home'), # 127.0.0.1:8000 과 views.py 폴더의 home 함수 연결 
    path('tweet/', views.tweet, name='tweet') # 127.0.0.1:8000/tweet 과 views.py 폴더의 tweet 함수 연결 
]

# mySpartaSns/urls.py 
from django.contrib import admin 
from django.urls import path, include 
urlpatterns = [ 
    path('admin/', admin.site.urls), 
    path('', include('user.urls')), 
    path('', include('tweet.urls')) 
]

#user/views.py 
def sign_in_view(request): 
    if request.method == 'POST': 
        username = request.POST.get('username', None) 
        password = request.POST.get('password', None) 
        me = auth.authenticate(request, username=username, password=password)  # 사용자 불러오기 
        if me is not None:  # 저장된 사용자의 패스워드와 입력받은 패스워드 비교 
            auth.login(request, me) 
            return redirect('/') # 여기 수정!!!!
        else: 
            return redirect('/sign-in')  # 로그인 실패 
    elif request.method == 'GET': 
        return render(request, 'user/signin.html')

<div class="col-md-3"> 
    <div class="card"> 
        <div class="card-body"> 
            <h5 class="card-title">{{ user.username }}</h5> 
            <p class="card-text"> {{ user.bio }}</p> 
        </div> 
    </div> 
</div>

<!-- templates/base.html --> 
		... 생략  
				<li class="nav-item"> 
            <a class="nav-link" href="#"> 친구 <span class="sr-only"></span></a> 
        </li> 
    </ul> 
</div> 
<form class="form-inline my-2 my-lg-0"> 
    {% if not user.is_authenticated %} # 요줄 중요! 
        <ul class="navbar-nav mr-auto"> 
            <li class="nav-item active"> 
                <a class="nav-link" href="/sign-in"> Sign In <span class="sr-only"></span></a> 
            </li> 
            <li class="nav-item active"> 
                <a class="nav-link" href="/sign-up"> Sign Up <span class="sr-only"></span></a> 
            </li> 
        </ul> 
    {% else %} #요줄 중요! 
        {{ user.username }} 님 반갑습니다! 
    {% endif %} # 요줄은 if 문이 끝났다는 걸 알려주는 것 같다!
</form> 
... 생략

# tweet/views.py 
from django.shortcuts import render, redirect 
def tweet(request): 
    if request.method == 'GET':  # 요청하는 방식이 GET 방식인지 확인하기 
        user = request.user.is_authenticated  # 사용자가 로그인이 되어 있는지 확인하기 
        if user:  # 로그인 한 사용자라면 
            return render(request, 'tweet/home.html') 
        else:  # 로그인이 되어 있지 않다면  
            return redirect('/sign-in')

# user/views.py 
def sign_in_view(request): 
    if request.method == 'POST': 
        username = request.POST.get('username', None) 
        password = request.POST.get('password', None) 
        me = auth.authenticate(request, username=username, password=password)  # 사용자 불러오기 
        if me is not None:  # 저장된 사용자의 패스워드와 입력받은 패스워드 비교 
            auth.login(request, me) 
            return redirect('/') 
        else: 
            return redirect('/sign-in')  # 로그인 실패 
    elif request.method == 'GET': 
        user = request.user.is_authenticated  # 사용자가 로그인 되어 있는지 검사 
        if user:  # 로그인이 되어 있다면 
            return redirect('/') 
        else:  # 로그인이 되어 있지 않다면 
            return render(request, 'user/signin.html')

#user/views.py 
from django.contrib.auth.decorators import login_required

@login_required 
def logout(request): 
    auth.logout(request) # 인증 되어있는 정보를 없애기 
    return redirect("/")

# user/urls.py 
from django.urls import path 
from . import views 
urlpatterns = [ 
    path('sign-up/', views.sign_up_view, name='sign-up'), 
    path('sign-in/', views.sign_in_view, name='sign-in'), 
    path('logout/', views.logout, name='logout') 
]

<!-- templates/base.html --> 
		... 생략  
				<li class="nav-item"> 
            <a class="nav-link" href="#"> 친구 <span class="sr-only"></span></a> 
        </li> 
    </ul> 
</div> 
<form class="form-inline my-2 my-lg-0"> 
    {% if not user.is_authenticated %} 
        <ul class="navbar-nav mr-auto"> 
            <li class="nav-item active"> 
                <a class="nav-link" href="/sign-in"> Sign In <span class="sr-only"></span></a> 
            </li> 
            <li class="nav-item active"> 
                <a class="nav-link" href="/sign-up"> Sign Up <span class="sr-only"></span></a> 
            </li> 
        </ul> 
    {% else %} 
        <ul class="navbar-nav mr-auto"> 
            <li class="nav-item" disabled> 
                <span class="nav-link"> 
                    {{ user.username }} 님 반갑습니다! 
                </span> 
            </li> 
            <li class="nav-item"> 
                <a class="nav-link" href="/logout"> 로그아웃 </a> 
            </li> 
        </ul> 
    {% endif %} 
</form> 
... 생략

... 생략 
<form action="/tweet/" method="post"> 
    {% csrf_token %} 
    <div class="form-group mb-2"> 
        <textarea class="form-control" style="resize: none" name='my-content' id="my-content"></textarea> 
    </div> 
    <button type="submit" class="btn btn-primary" style="float:right;">작성하기</button> 
</form> 
... 생략

from django.urls import path 
from . import views 
urlpatterns = [ 
    path('', views.home, name='home'), 
    path('tweet/', views.tweet, name='tweet') 
]

from .models import TweetModel # 글쓰기 모델 -> 가장 윗부분에 적어주세요! 
def tweet(request): 
    if request.method == 'GET':  # 요청하는 방식이 GET 방식인지 확인하기 
        user = request.user.is_authenticated  # 사용자가 로그인이 되어 있는지 확인하기 
        if user:  # 로그인 한 사용자라면 
            return render(request, 'tweet/home.html') 
        else:  # 로그인이 되어 있지 않다면 
            return redirect('/sign-in') 
    elif request.method == 'POST':  # 요청 방식이 POST 일때 
        user = request.user  # 현재 로그인 한 사용자를 불러오기 
        my_tweet = TweetModel()  # 글쓰기 모델 가져오기 
        my_tweet.author = user  # 모델에 사용자 저장 
        my_tweet.content = request.POST.get('my-content', '')  # 모델에 글 저장 
        my_tweet.save() 
        return redirect('/tweet')

# tweet/views.py

def tweet(request):
    if request.method == 'GET':  # 요청하는 방식이 GET 방식인지 확인하기
        user = request.user.is_authenticated  # 사용자가 로그인이 되어 있는지 확인하기
        if user:  # 로그인 한 사용자라면
            all_tweet = TweetModel.objects.all().order_by('-created_at') # 여기랑 
            return render(request, 'tweet/home.html', {'tweet': all_tweet}) # 여기가 중요. 
        else:  # 로그인이 되어 있지 않다면
            return redirect('/sign-in')
    elif request.method == 'POST':  # 요청 방식이 POST 일때
        user = request.user  # 현재 로그인 한 사용자를 불러오기
        my_tweet = TweetModel()  # 글쓰기 모델 가져오기
        my_tweet.author = user  # 모델에 사용자 저장
        my_tweet.content = request.POST.get('my-content', '')  # 모델에 글 저장
        my_tweet.save()
        return redirect('/tweet')

<!-- templates/tweet/home.html -->
<hr>
<!-- 작성 된 글이 나오는 곳 -->
<div class="row">
    {% for tw in tweet %}
        <div class="col-md-12 mb-2">
            <div class="card">
                <div class="card-body">
                    <div class="media">
                        <div class="media-body">
                            <h5 class="mt-0">{{ tw.content }}</h5>
                        </div>
                        <div style="text-align: right">
                            <span style="font-size: small">{{ tw.author.username }}-{{ tw.created_at|timesince }} 전</span>
                        </div>
                    </div>
                </div>
            </div>
        </div>
    {% endfor %}
</div>

# tweet/views.py
from django.contrib.auth.decorators import login_required


@login_required
def delete_tweet(request, id):
    my_tweet = TweetModel.objects.get(id=id)
    my_tweet.delete()
    return redirect('/tweet')

# tweet/urls.py

from django.urls import path
from . import views

urlpatterns = [
    path('', views.home, name='home'),
    path('tweet/', views.tweet, name='tweet'),
    path('tweet/delete/<int:id>', views.delete_tweet, name='delete-tweet'),
]

django-admin startapp user #사용자 관리 담당할 user
django-admin startapp tweet #글 관리 담당할 tweet

INSTALLED_APPS = [ 
    'django.contrib.admin', 
    'django.contrib.auth', 
    'django.contrib.contenttypes', 
    'django.contrib.sessions', 
    'django.contrib.messages', 
    'django.contrib.staticfiles', 
    'tweet', #
    'user',  # 두개 추가!
]

#user/models.py 
from django.db import models 
# Create your models here. 
class UserModel(models.Model):

    class Meta: 
        db_table = "my_user"

    username = models.CharField(max_length=20, null=False) 
    password = models.CharField(max_length=256, null=False) 
    bio = models.CharField(max_length=256, default='') 
    created_at = models.DateTimeField(auto_now_add=True) 
    updated_at = models.DateTimeField(auto_now=True)

from django.contrib import admin
from .models import UserModel



# Register your models here.

admin.site.register(UserModel) # 이 코드가 나의 UserModel을 Admin에 추가 해 줍니다

# tweet/models.py
from django.db import models
from user.models import UserModel




# Create your models here.
class TweetModel(models.Model):
    class Meta:
        db_table = "tweet"



    author = models.ForeignKey(UserModel, on_delete=models.CASCADE)
    #ForeignKey는 '외부 모델을 가져와서 사용하겠다.' 라는 얘기
    content = models.CharField(max_length=256)
    created_at = models.DateTimeField(auto_now_add=True)
    updated_at = models.DateTimeField(auto_now=True)

from django.contrib import admin
from .models import TweetModel

# Register your models here.
admin.site.register(TweetModel)

# mySpartaSns/urls.py
from django.contrib import admin
from django.urls import path, include



urlpatterns = [
    path('admin/', admin.site.urls),
    path('', include('user.urls')) #user앱의 urls.py에 연결시키겠다! 라고 선언 해 주는 코드 
]

from django.shortcuts import render


# Create your views here.
def sign_up_view(request):
    return render(request, 'user/signup.html')


def sign_in_view(request):
    return render(request, 'user/signin.html')

from django.urls import path
from . import views

urlpatterns = [
    path('sign-up/', views.sign_up_view, name='sign-up'),
    path('sign-in/', views.sign_in_view, name='sign-in'),
]

def sign_up_view(request):
    if request.method == 'GET': # GET 메서드로 요청이 들어 올 경우
        return render(request, 'user/signup.html')
    elif request.method == 'POST': # POST 메서드로 요청이 들어 올 경우
        
        return ""

<!-- 윗 부분 생략 -->
<div class="wrap">
    <h2 class="title-center"> 회원가입 </h2>
    <form class="form-area" method="post" action="/sign-up/">
        {% csrf_token %}
        <div class="form-group mt-2 mb-2">
            <label for="username">이름</label>
            <input type="text" class="form-control" id="username" name="username">
        </div>
        <div class="form-group mt-2 mb-2">
<!-- 아랫 부분 생략 -->

# user/views.py
from django.http import HttpResponse



def sign_in_view(request):
		if request.method == 'POST':
        return HttpResponse("로그인 성공!")
    elif request.method == 'GET':
        return render(request, 'user/signin.html')

# user/views.py
def sign_in_view(request):
    if request.method == 'POST':
        username = request.POST.get('username', None)
	password = request.POST.get('password', None) 


        return HttpResponse("로그인 성공!")
    elif request.method == 'GET':
        return render(request, 'user/signin.html')

# user/views.py
def sign_in_view(request):
    if request.method == 'POST':
        username = request.POST.get('username', None)
        password = request.POST.get('password', None)

        me = UserModel.objects.get(username=username)  # 사용자 불러오기
        if me.password == password:  # 저장된 사용자의 패스워드와 입력받은 패스워드 비교
            request.session['user'] = me.username  # 세션에 사용자 이름 저장
            return HttpResponse("로그인 성공!")
        else: # 로그인이 실패하면 다시 로그인 페이지를 보여주기
            return redirect('/sign-in')
    elif request.method == 'GET':
        return render(request, 'user/signin.html')

filter(조건 함수, 순회 가능한 데이터)
filter() 함수는 두번째 인자로 넘어온 데이터 중에서 첫번째 인자로 넘어온 조건 함수를 만족하는 데이터만을 반환합니다.

return HttpResponse(f"안녕하세요{username}님. 로그인 되었습니다.")