from django.db import models
from users.models import User

class Upload(models.Model): #나는 포스팅대신 업로드라는 이름을 사용했다
    user_id = models.ForeignKey(User, on_delete=models.CASCADE, db_column='user_id')
    #User테이블의 id를 참조하는 'user_id'이름의 컬럼을 만든다.
    created_at = models.DateTimeField(auto_now_add=True)
    text = models.CharField(max_length=300)
    img = models.CharField(max_length=400)
    
    class Meta:
        db_table = 'uploads'

import json

from django.views   import View
from django.http    import JsonResponse

from .models        import Upload as UploadModel 
#AttributeError: type object 'Upload' has no attribute 'objects'
#이 에러가 자꾸나서 스택오버플로우에서 찾은대로 as UploadModel로 갈음해주었다.
from users.models   import User
from users.utils    import login_decorator
#데코레이터는 유저스앱안에 따로 유틸스파일에 들어있다.

class Upload(View):
    @login_decorator #유저가 올바른 토큰을 가져왔다면
    def post(self, request):
        try:
            data = json.loads(request.body)

            if (data["img"] == ""): #이미지가 없으면 에러
                return JsonResponse({"message": "EMPTY_IMAGE"}, status=400)

            UploadModel.objects.create( #디비에 값을 추가
                user_id      = User.objects.get(id = request.user.id),
                #요청을 수행하는 유저의 아이디 
                img        = data["img"],
                text     = data["text"]
            )
            return JsonResponse({"message": "SUCCESS"}, status=201)

        except KeyError:
            return JsonResponse({"message": "KEY_ERROR"}, status=400)

    def get(self, request):
            uploads = UploadModel.objects.all()
            #업로드모델에 따라 객체를 다 가져와서 저장
            results = []

            for upload in uploads: #저장된 객체들을 한 개씩 돌면서
                results.append({
                    "user_id"      : upload.user_id.id,
                    #객체의 유저아이디번호에 해당하는 id
                    "img"        : upload.img,
                    "text"     : upload.text,
                    "created_at" : upload.created_at
                })
            return JsonResponse({"results": results}, status=200)

import jwt

from django.http            import JsonResponse
from django.core.exceptions import ObjectDoesNotExist

from my_settings            import SECRET_KEY
from .models                import User

def login_decorator(func):
    def wrapper(self, request, *args, **kwargs):
        #들어올 수 있는 인자를 모두 받도록 한다
        try:
            token         = request.headers.get("Authorization", None)
            #헤더에서 Authorization(헤더에 있는 속성)을 가져와서 토큰에 저장한다.
            user          = jwt.decode(token, SECRET_KEY, algorithms='HS256')
            #토큰을 시크릿키를 이용해 디코드해서 유저 아이디를 알아내서 유저에 저장한다.
            request.user  = User.objects.get(id = user['id'])
            #유저의 아이디에 해당하는 유저객체를 리퀘스트.유저에 저장한다.

            return func(self, request, *args, **kwargs)
            #받은 인자들을 모두 전달해준다(예를 들어 이미지, 텍스트 등등)

        except jwt.exceptions.DecodeError:
            return JsonResponse({"message" : "INVALID_TOKEN"}, status=400)

        except ObjectDoesNotExist:
            return JsonResponse({"message" : "INVALID_USER"}, status=400)

    return wrapper

#상위프로젝트폴더urls.py
from django.urls import path,include

urlpatterns = [
    path("users",include("users.urls")),
    path("upload",include("upload.urls"))
]

#하위앱폴더urls.py
from django.urls import path
from .views      import Upload

urlpatterns = [
    path("", Upload.as_view())
]

#yooyoung > users > views.py

import json, re, bcrypt, jwt #brcypt(암호화)와 jwt(토큰) 임포트
#...
from westagram.settings  import SECRET_KEY #세팅파일에서 시크릿 키 불러오기

class SignUp(View):
    def post(self, request):
        try:
            data = json.loads(request.body)
            hashed_password = bcrypt.hashpw(data['password'].encode('UTF-8'), bcrypt.gensalt())
            #유저에게 받은 새 문자열 비밀번호를 인코딩해서 바이트형태로 이진화하고, 비크립트로 암호화한다.

            #...

            User.objects.create(
                password     =   hashed_password.decode('UTF-8'),
                #DB에 문자열로 저장하기 위해서 암호화된 바이트형태의 비밀번호를 디코딩해준다.
            )

password = '1234'
hashed_password = bcrypt.hashpw(password.encode('utf-8'), bcrypt.gensalt())
new_password = '1234'
bcrypt.checkpw(new_password.encode('utf-8'),hashed_password)
True

class SignIn(View):
    def post(self, request):
        try:
            #...
            user = User.objects.get(email=data['email'])
            #유저가 반복해서 나오니까 변수로 저장

            if not bcrypt.checkpw(data['password'].encode('UTF-8'), user.password.encode('UTF-8')):
                return JsonResponse({"massage": "INVALID_USER"}, status=401)
                #유저에게 로그인시 입력받은 문자열 비밀번호를 인코딩(이진화)해서 디비에 저장된 비밀번호를 인코딩한 것과 비교해서
                #같으면 트루를 반환한다. 같지 않으면 에러를 반환한다.  

            token = jwt.encode({'user_id': user.id}, SECRET_KEY, algorithm='HS256')
            #입력받은 유저의 아이디로 토큰을 생성

            return JsonResponse({'token': token}, status = 200)
            #이메일과 비밀번호가 일치하는 경우 유저에게 토큰을 전달한다.

        except KeyError:
            return JsonResponse({"massage": "KEY_ERROR"}, status=400)

pip install pyjwt
import jwt
SECRET = 'secret' #'랜덤한 조합의 키' 예제이므로 단순하게 'secret'이라고 하겠습니다.
token = jwt.encode({'id' : 1}, SECRET, algorithm = 'HS256') #토큰을 만드는 문법
print(token)
'eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.eyJpZCI6MX0.-xXA0iKB4mVNvWLYFtt2xNiYkFpObF54J9lj2RwduAI'

header = jwt.decode(token, SECRET, algorithm = 'HS256')
print(header)
{'id': 1}

def cut_str(s):
    length =[]
    result = ""
    
    if len(s)==1:  #문자열 길이가 1이면 결과는 무조건 1 
         return 1
    for cut in range(1, len(s)//2+1): #1 부터 문자열의 절반까지 자르며 비교해야하기떄문에
        temp = s[:cut]     #초기값 설정
        num = 1
        for i in range(cut, len(s), cut): #정해진 길이를 문자열 s의 길이까지 정해진 길이 스텝으로 반복
            if s[i:i+cut] == temp:    #만약 다음으로 자른값과 같을경우
                num+=1      #숫자 올려줌 (문자열 앞에 붙을 숫자)
            else:       #다를 경우
                if num == 1:  #숫자가 1 이면 문자열에 붙지 않으므로 없애줌
                    num=""
                result += str(num)+temp   #결과값에 숫자와 temp에 저장된 값을 저장
                temp = s[i:i+cut]   #temp값을 변경
                num=1       #숫자 다시 초기화
        if num == 1:  #else로 끝날을때만 저장이 되므로 반복
            num=""
        result +=str(num)+temp
        length.append(len(temp))
        temp=""
    return min(length) #최소값을 반환

#yooyoung > users > urls.py
from django.urls import path
from .views      import SignUp, SignIn

urlpatterns = [
    path("/signup", SignUp.as_view()),
    path("/signin", SignIn.as_view())
]

#yooyoung > users > views.py
class SignIn(View):
    def post(self, request):
        try: #예외처리
            data = json.loads(request.body)
            #프론트에서 json으로 데이터 받기

            if (data["email"] == "") or (data["password"] == ""):
                return JsonResponse({'message': 'KEY_ERROR'}, status=400)
                #이메일이나 비밀번호가 입력되지 않았으면 에러 반환
            
            if not User.objects.filter(email=data['email']).exists():
                return JsonResponse({'message': 'INVALID_USER'}, status=401)
                #유저가 입력한 이메일이 디비에 존재하지 않으면 에러 반환

            if not User.objects.filter(password=data['password']):
                return JsonResponse({'massage': 'INVALID_USER'}, status=401)
                #유저가 입력한 이메일이 존재해서 넘어왔으나 비밀번호가 디비와 일치하지 않으면 에러 반환

            if User.objects.filter(email=data['email']) and User.objects.filter(password=data['password']):
                return JsonResponse({'message': 'SUCCESS'}, status=200)
                #유저가 입력한 이메일과 비밀번호가 디비와 일치하면 성공

        except KeyError:
            return JsonResponse({'massage': 'KEY_ERROR'}, status=400)
            #예외처리 : 원본 코드에서 없는 key를 접근하려고 했을때 KeyError 가 발생

def two_sum(nums, target):
  for i in range(len(nums)):
    for j in range(len(nums)):
      if nums[i]+nums[j] == target:
        #주어진 수 둘의 조합이 합쳐서 target이 되는 경우 해당 수 출력
        return [i,j]

def reverse(number):
  if number > 0:
      return int(str(number)[::-1])
      #양수일때는 그냥 뒤집기
  if number < 0:
      return int('-'+str(number*-1)[::-1])
      #음수일때는 -뺐다가 붙임
  else:
      return 0 #0일때는 0

def get_len_of_str(s):
    temp_list = []
    max_len = 0
    str_list = list(s)
    for i in str_list:
        if i in temp_list:
            temp_list=[]
            #2.해당 알파벳이 이미 리스트에 있다면 리스트를 비운다 
        temp_list.append(i)
        #1.처음 나오는 알파벳들을 리스트에 넣는다
        if len(temp_list) > max_len:
            max_len = len(temp_list)
            #3. 리스트의 길이가 현재까지 갱신된 최고 길이보다 길면 최고 길이를 갈음한다
    return max_len

def same_reverse(num):
  return str(num) == str(num)[::-1]
  #뒤집어서 같으면 True 다르면 False 반환

def get_prefix(strs):
    answer=[]
    strs = sorted(strs)
    #sort하면 a, ab, abc, ac 이렇게 정렬이 된다
    if strs == []:
      return ''
    #빈문자열 예외처리
    for i in range(len(strs[-1])):
        if strs[0][i] == strs[-1][i]:
          #첫문자와 마지막문자의 알파벳 비교
            answer.append(strs[0][i])
            #같으면 답에 넣는다 
        else:
          break
    return ''.join(answer)

python manage.py makemigrations users
python manage.py migrate users

#yooyoung > users > models.py
from django.db import models


class User(models.Model):
    name         = models.CharField(max_length=40, null=True)
    #null=True를 넣으면 값이 들어오지 않아도 에러가 나지 않는다.
    email        = models.EmailField(max_length=200, unique=True)
    password     = models.CharField(max_length=200)
    age          = models.PositiveIntegerField(null=True)
    phone_number = models.CharField(max_length=60, null=True)

    class Meta:
        db_table = 'users' #디비 이름 네이밍 컨벤션 : 소문자 복수형

#yooyoung > urls.py
from django.urls import path,include

urlpatterns = [
    path("users",include("users.urls"))
]

#yooyoung > users > urls.py
from django.urls import path
from .views      import SignUp

urlpatterns = [
    path("", SignUp.as_view())
]

#yooyoung > users > views.py
from django.views import View
from django.http import JsonResponse
from .models import User
import json
import re


class SignUp(View):
    def post(self, request):
        try:
            data = json.loads(request.body)

            if User.objects.filter(email=data['email']).exists():
                return JsonResponse({"message": "ERROR_EMAIL_ALREADY_EXIST"}, status=400)
                #이메일이 디비에 이미 있는 경우 중복에러
            if (data["email"] == "") or (data["password"] == ""):
                return JsonResponse({"message": "ERROR_EMPTY_EMAIL_OR_PASSWORD"}, status=400)
                #이메일이나 비밀번호가 누락된 경우 에러
            if re.match(r"^[a-zA-Z0-9+-_.]+@[a-zA-Z0-9-]+\.[a-zA-Z0-9-.]+$", data["email"]) == None:
                return JsonResponse({"message": "ERROR_EMAIL_NEED_@AND."}, status=400)
                #이메일 형식이 안 맞는 경우 에러
            if re.match(r"^(?=.*[A-Za-z])(?=.*\d)(?=.*[$@$!%*#?&])[A-Za-z\d$@$!%*#?&]{8,}$", data["password"]) == None:
                #(알파벳이 있고)(숫자가 있고)(특수문자가 있으면)8자 이상의 해당 문자열을 입력받는다.
                # 그래서 특수문자에 넣고싶은 문자가 더 있으면 여기에 추가해주면 된다. 양쪽에 다 추가해야함! 
                return JsonResponse({"message": "ERROR_REQUIRE_8_LETTER,NUMBER,SPECIAL_SYMBOLS)"}, status=400)
                #비밀번호 8자리 이상, 문자, 숫자, 특수문자의 복합아니면 에러

            User.objects.create(
                name         =   data['name'],
                email        =   data['email'],
                password     =   data['password'],
                phone_number =   data['phone_number'],
                age          =   data['age']
            )
            #그렇지 않은 경우 데이터 저장

            return JsonResponse({'Message': 'SUCCESS'}, status=201)
        
        except KeyError:
            return JsonResponse({'message': 'KEY_ERROR'}, status=400)
            #try: except를 써야 예외처리할 수 있다. 키에러일 경우 키에러를 리턴한다.

http -v POST 127.0.0.1:8000/app이름/urls등록한이름 컬럼='' 컬럼='' 
공백으로 컬럼을 구분한다.

from django.db import models

class Actor(models.Model):
    first_name = models.CharField(max_length=45)
    last_name = models.CharField(max_length=45)
    birth_date = models.DateField()
    movie = models.ManyToManyField('Movie')
    class Meta:
        db_table='actors'
    def __str__(self):
        return self.first_name + self.last_name

class Movie(models.Model):
    title = models.CharField(max_length=45)
    release_date = models.DateField()
    running_time = models.IntegerField()
    class Meta:
        db_table='movies'
    def __str__(self):
        return self.title

# movie > views.py
import json

from django.http import JsonResponse
from django.views import View

from movie.models import Movie, Actor

class ActorView(View):
    def get(self, request):
        actors = Actor.objects.all()
        results=[]
        for actor in actors:
            #movies = [{movie.title for movie in actor.movie.all()}]
            # for movie in actor.movie.all():
            results.append(
            {
                "name" : actor.first_name + ' ' + actor.last_name,
                "Filmography" : [{"movie" : movie.title} for movie in actor.movie.all()]
            }
        )
        return JsonResponse({'result':results}, status=200)

class MovieView(View):
    def get(self, request):
        movies = Movie.objects.all()
        results=[]
        for movie in movies:
            results.append(
            {
                "title" : movie.title,
                "running time" : movie.running_time
            }
        )
        return JsonResponse({'result':results}, status=200)

from django.urls import path

urlpatterns = [
    path('movie', include('movie.urls'))
]
# 부모 urls.py, server로 movie 앱을 사용하겠다는 요청이 오면 movie로 보내주는 역할을 한다.

from django.urls   import path
from movie.views     import MovieView, ActorView

urlpatterns = [
    path('/actor', ActorView.as_view()),
    path('/movie', MovieView.as_view()),
    #as_view는 해당 경로까지 온 요청이 어떤 method인지 판단해주는 함수이다.
]

class ActorView(View):
    def get(self, request):
        actors = Actor.objects.all()
        results=[]
        for actor in actors:
            results.append(
                {
                    "name" : actor.first_name + ' ' + actor.last_name,
                    "Filmography" : [movie.title for movie in list(actor.movie.all())]
                }
            )
        return JsonResponse({'result':results}, status=200)

pythong manage.py runserver

from django.db import models

class Owner(models.Model):
    name = models.CharField(max_length=45)
    email = models.EmailField(max_length=254)
    age = models.BigIntegerField
    class Meta: 
        db_table = 'owners' 
    def __str__(self):
        return self.name

class Dog(models.Model):
    name = models.CharField(max_length=45)
    owner = models.ForeignKey('Owner', on_delete=models.CASCADE, default='')
    age = models.BigIntegerField
    class Meta:
        db_table='dogs'  
    def __str__(self):
        return self.name

python manage.py makemigrations 
#모델의 변경사항을 파악, 설계도 작성(하고나서 만들어진 파일을 잘 살펴본다)
python manage.py showmigrations
#현재 migrations가 어떤 상태인지 살펴보기
python manage.py sqlmigrate dog 0001
#실제 데이터베이스에 전달되는 SQL 쿼리문을 확인
python manage.py migrate 
#자동으로 migration을 실행

DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.sqlite3',
        'NAME': os.path.join(BASE_DIR, 'db.sqlite3'),
    }
}
#settings.py에서 이걸 지워야된다

python manage.py shell 

# dog>views.py
import json

from django.http import JsonResponse
from django.views import View

from dog.models import Dog, Owner
class DogView(View):
    def get(self, request):
        dogs = Dog.objects.all()
        results=[]
        for dog in dogs:
            results.append(
            {
                "name" : dog.name,
                "owner" : dog.owner.name
            }
        )
        return JsonResponse({'result':results}, status=200)

class OwnerView(View):
    def get(self, request):
        owners = Owner.objects.all()
        results=[]
        for owner in owners:
            results.append(
            {
                "name" : owner.name,
                "email" : owner.email,
                "dogs" : owner.dog.name
            }
        )
        return JsonResponse({'result':results}, status=200)

#dog_owner(상위 프로젝트 폴더) > urls.py
#상위 프로젝트 폴더 dog_owner가 dog앱 안의 urls을 바라보게 만들어줌
from django.urls import path, include

urlpatterns = [
    path('dog', include('dog.urls'))
]

#dog(하위 앱 폴더, urls.py새로 만들어주어야함) > urls.py
#하위 앱 폴더 dog에서 DogView를 연결
from django.urls   import path
from dog.views     import OwnerView, DogView
#OwnerView, DogView 는 view.py로부터 get, post 기능을 수행하는 클래스를 import해온다.

urlpatterns = [
    path('/dog', DogView.as_view()),
    path('/owner', OwnerView.as_view()),
    #as_view는 해당 경로까지 온 요청이 어떤 method인지 판단해주는 함수이다.
]

#url의 위치
.
├── manage.py
├── products
│   ├── models.py
│   ├── urls.py (없음, 새로 생성해야함)
│   └── views.py
└── westarbucks
    └── urls.py : main urls.py (부모, 요청 url 분석을 가장 먼저 하는 위치)

# dog>views.py
import json

from django.http import JsonResponse
from django.views import View

from .models import Dog, Owner

class OwnerView(View):
    def post(self, request):
        data  = json.loads(request.body)
        # view는 받아온 json 데이터를 template의 html 파일로 전달하고 
        # 템플릿으로 전달된 json 데이터는 자바스크립트에 의해 활용할 수 있는 
        # 형태로 다시 받아온다. 자바스크립트로 json데이터를 자유롭게 사용할 수 있다.
        name = data['name']
        # 받아온 json데이터 중 변수 name의 키값을 name변수에 저장한다 
        email= data['email']
        Owner.objects.create(name = name, email=email)        
        # Owner모델을 이용해서 받아온 name과 email의 값을 가진 데이터를 추가한다.
        return JsonResponse({'Message':'Created'}, status=201)

    def get(self, request):
        owners = Owner.objects.all()
        results=[]
        for owner in owners:
            dogs = 
            [
                {"이름":dog.name} for dog in Dog.objects.filter(owner_id=owner.id)
            ]
            # for문부터 읽어서, model에서 owner의 포린키 아이디(owner_id)가 
            # 오너의 아이디(owner.id)와 일치하는 개들을 filter로 불러와서 
            # "이름": 값 형태로 dogs라는 변수에 저장한다.
            results.append(
            {
                "name" : owner.name,
                "email" : owner.email,
                "dog_list" : dogs
            }
        )
        return JsonResponse({'result':results}, status=200)

class DogView(View):
    def post(self, request):
        data = json.loads(request.body)
        # owner = Owner.objects.get(name = data['owner']) 이렇게 해서 owner = owner라고 써줘도 됨
        # 프론트에서 준 데이터인 오너의 이름을 가진 데이터들을 불러와서 owner변수에 저장
        dog = Dog.objects.create(
            name = data['name'], 
            owner_id = data['owner_id']
        )
        # Dog모델을 이용해서 받아온 name과 owner의 값을 가진 데이터를 추가한다.

            if not Owner.objects.filter(id=data["owner_id"].exists():
                return JsonResponse({"message": "Owner_does_not_exist", status=404})
            
        return JsonResponse({'Message':'Created'}, status=201)

    def get(self, request):
        dogs = Dog.objects.all()
        results=[]
        for dog in dogs:
            results.append(
            {
                "name" : dog.name,
                "owner" : dog.owner.name
            }
        )
        return JsonResponse({'result':results}, status=200)

dogs = [{"이름":dog.name} for dog in Dog.objects.filter(owner_id=owner.id)]

mysql.server start
mysql -u root -p #마이sql시작

from pathlib        import Path #기존에 settings.py 에 있는 코드
from my_settings   import DATABASES, SECRET_KEY

#시크릿 키와 데이터베이스 변수는 my_settings파일을 만들어서 갈음한다.
SECRET_KEY = SECRET_KEY # 기존의 시크릿키 변수 삭제 후 대체
DATABASES = DATABASES # 기존의 데이터베이스 변수 삭제 필수!

ALLOWED_HOSTS = ['*'] #수정 : 모두 접속 가능

APPEND_SLASH = False #추가 : 슬래시 자동으로 삽입하지 않음

INSTALLED_APPS = [
    # 'django.contrib.admin', #admin도 
    # 'django.contrib.auth', #login auth도 직접 만들어쓸 예정이다
    'django.contrib.contenttypes',
    'django.contrib.sessions',
    'django.contrib.messages',
    'django.contrib.staticfiles',
    'corsheaders', # corsheaders 추가
    'products', #앱을 새로 만들면 여기에 추가해야한다
]
MIDDLEWARE = [
    'django.middleware.security.SecurityMiddleware',
    'django.contrib.sessions.middleware.SessionMiddleware',
    'django.middleware.common.CommonMiddleware',
    # 'django.middleware.csrf.CsrfViewMiddleware', csrf 주석처리
    # 'django.contrib.auth.middleware.AuthenticationMiddleware', auth 주석처리
    'django.contrib.messages.middleware.MessageMiddleware',
    'django.middleware.clickjacking.XFrameOptionsMiddleware',
    'corsheaders.middleware.CorsMiddleware', #corsheaders middleware 추가
]

# 데이터베이스 부분 삭제
# 뒷부분 생략

#REMOVE_APPEND_SLASH_WARNING 추가
APPEND_SLASH = False

##CORS
CORS_ORIGIN_ALLOW_ALL=True
CORS_ALLOW_CREDENTIALS = True

CORS_ALLOW_METHODS = (
    'DELETE',
    'GET',
    'OPTIONS',
    'PATCH',
    'POST',
    'PUT',
)

CORS_ALLOW_HEADERS = (
    'accept',
    'accept-encoding',
    'authorization',
    'content-type',
    'dnt',
    'origin',
    'user-agent',
    'x-csrftoken',
    'x-requested-with',
	#만약 허용해야할 추가적인 헤더키가 있다면?(사용자정의 키) 여기에 추가하면 됩니다.
)

#클라우드에 올리지 않는, 키를 보관하는 파일
DATABASES = {
    'default' : {
        'ENGINE': 'django.db.backends.mysql',
        'NAME': 'westarbucks_db',
        'USER': 'root',
        'PASSWORD': '',
        'HOST': '127.0.0.1', #데이터베이스의 IP주소, 이건 각자의 컴퓨터
        'PORT': '3306',
    }
}
SECRET_KEY ='_9^=58g2r*r(6@q7ugn!fxg-!fo48$7af9i4yn9-1$+...'
#setting.py에 있던 시크릿 키를 붙여넣음

from django.urls import path

urlpatterns = [
]

pythong manage.py runserver

pip freeze > requirements.txt

Django==3.2.6
django-cors-headers==3.7.0
mysql-client==0.0.1
PyMySQL==1.0.2 #맥 M1의 경우 설치한 파일

#(참고) 프로젝트 디렉토리 구조 구조
.
└── suntae
    ├── manage.py
    ├── my_settings.py
    └── westagram
        ├── \__init__.py
        ├── asgi.py
        ├── settings.py
        ├── urls.py
        └── wsgi.py

python manage.py makemigrations 
#모델의 변경사항을 파악, 설계도 작성(하고나서 만들어진 파일을 잘 살펴본다)
python manage.py showmigrations 
#현재 migrations가 어떤 상태인지 살펴보기
python manage.py sqlmigrate [앱이름] [마이그레이션번호]
#실제 데이터베이스에 전달되는 SQL 쿼리문을 확인
python manage.py migrate 
#자동으로 migration을 실행

In  : Category.objects.create(name='콜드브루')
Out : <Category: Category object (1)>

#category 변수에 반환된 값을 저장하고, 생성된 data를 사용할 수 있다.
#인스턴스로 반환되므로 category.name으로 class 안에 변수에 접근할 수 있다.
In  : category = Category.objects.create(name='콜드브루')
In  : category.name
Out : '콜드브루'

참고) save method : INSERT 또는 UPDATE
Category(name='콜드브루').save()

In  : Category.objects.get(id=1)
Out : <Category: Category object (1)>

In  : Category.objects.filter(name='탄산').update(name='콜드브루')
Out : 2 #총 업데이트된 row 개수

In  : Category.objects.filter(name='qp').delete()
Out : (1, {'products.Category': 1})

In  : category = Category.objects.get(id=2)
Out : <Category: Category object (2)>

In  : category.name
Out : '브루드커피'

In  : category.name = 'new name'
In  : category.save()

In  : category.name
Out : 'new name'

In  : Category.objects.all()
Out : <QuerySet [<Category: Category object (2)>, <Category: Category object (3)>, <Category: Category object (4)>, <Category: Category object (5)>, <Category: Category object (6)>, <Category: Category object (7)>]>

In  : for category in Category.objects.all()
		print(category.name)

#아래와 같이 인스턴스들이 담겨 있는 QuerySet이 반환되기 때문에, 모든 속성에 접근해서 데이터를 관리할 수 있습니다.
Out : 티
      브루드커리
      브루드커피
      콜드브루
      콜드브루

case1
In  : Category.objects.filter(name='브루드커피')
Out : [<Category: Category object (3)>, <Category: Category object (4)>]

case2
In  : Category.objects.filter(name='브루드커피').filter(id=3)
Out : [<Category: Category object (3)>]

case3
In  : Category.objects.filter(name='브루드커피').exclude(id=3)
Out : [<Category: Category object (4)>]

In  : Category.objects.filter(name='브루드커피')
Out : [<Category: Category object (3)>, <Category: Category object (4)>]

In  : Category.objects.filter(name='브루드커피').values()
Out : <QuerySet [{'id': 3, 'name': '브루드커피', 'created_at': datetime.datetime(2020, 9, 8, 5, 43, 30, 4068, tzinfo=<UTC>), 'updated_at': datetime.datetime(2020, 9, 8, 5, 43, 30, 21801, tzinfo=<UTC>)}, {'id': 4, 'name': '브루드커피', 'created_at': datetime.datetime(2020, 9, 8, 5, 43, 30, 4068, tzinfo=<UTC>), 'updated_at': datetime.datetime(2020, 9, 8, 5, 43, 30, 21801, tzinfo=<UTC>)}]>

In  : Category.objects.filter(name='브루드커피').values_list()
Out : <QuerySet [(3, '브루드커피', datetime.datetime(2020, 9, 8, 5, 43, 30, 4068, tzinfo=<UTC>), datetime.datetime(2020, 9, 8, 5, 43, 30, 21801, tzinfo=<UTC>)), (4, '브루드커피', datetime.datetime(2020, 9, 8, 5, 43, 30, 4068, tzinfo=<UTC>), datetime.datetime(2020, 9, 8, 5, 43, 30, 21801, tzinfo=<UTC>))]>

python manage.py shell #파이썬에서 쉘 열기
>>>from products.models import Menu
#쉘에서 장고를 연결해주려면 import해야함, 시작 전 작성한 모델 클래스 import
>>> Menu.objects.create(name = '음료')  #class명.objects.method명(~~)

from products.models import Nutrition
Nutrition.objects.create(product_id=1, one_serving_kcal=75, sodium_mg=20, saturated_fat_g=2, sugars_g=10, caffeine_mg=245)

class Nutrition(models.Model):
    kcal = models.DecimalField(max_digits=5, decimal_places=1, null=True)
    sodium = models.DecimalField(max_digits=5, decimal_places=1, null=True)
    s_fat = models.DecimalField(max_digits=5, decimal_places=1, null=True)
    sugar = models.DecimalField(max_digits=5, decimal_places=1, null=True)
    protein = models.DecimalField(max_digits=5, decimal_places=1, null=True)
    caffeine = models.DecimalField(max_digits=5, decimal_places=1, null=True)
    product = models.OneToOneField('Product', on_delete=models.CASCADE)
    
    class Meta:
        db_table = 'nutritions'

Owner.objects.get(name = data['owner'])

[{"이름":dog.name, "나이":dog.age} for dog in Dog.objects.filter(owner_id=owner.id)]