크게 정리를 해보자면

1. ssh-key 만들기
2. github에서 ssh설정하기
3. ssh config 설정
4. git config 설정

   1. ssh-key 만들기

   우선 cd ~/.ssh 로 이동하여ssh-key 만들기 $ ssh-keygen -t rsa -b 4096 -C "본인의 깃헙메일주소" ex) ssh-keygen -t rsa -b 4096 -C "wjdals.yoon14@gmail.com"

개인용과 회사용을 구분하기 위해 id_rsa_personal라고 해주기 Enter file in which to save the key (~/.ssh/id_rsa): id_rsa_personal 그러면 예쁜그림?과 함께 ssh-key가 생성된다.

동일한 방법으로 회사용 ssh-key도 만들기! id_rsa_work

 $ cd ~/.ssh
 $ ls
config              
id_rsa_personal     
id_rsa_work.pub
id_rsa              
id_rsa_personal.pub 
known_hosts
id_rsa.pub          
id_rsa_work

~.pub파일을 복사하여 github에 붙여넣기 터미널창에서 해당 파일 열고 싶을 때? $ cat id_rsa_personal.pub 자세한 설명은 생활코딩 ssh Youtube

2. ssh config 설정

~/.ssh에서 config파일 생성하기

# personal
Host personal
HostName github.com
User git
IdentityFile ~/.ssh/id_rsa_personal

# work
Host work
HostName github.com
User git
IdentityFile ~/.ssh/id_rsa_work

IdentityFile에는 private key 파일의 위치를 입력한다.

3. .gitconfig 작성

터미널창에 vim ~/.gitconfig 입력하여 파일 작성하기

# This is Git's per-user configuration file.
[user]
    name = jmyoon     
    email = wjdals.yoon14@gmail.com
# work
[includeIf "/Users/jmin/devel/work/"]     
    path = .gitconfig-work

includeIf "파일경로" 는 해당 파일경로 있는 것들은 .gitconfig-work로 path설정 work디렉토리에 있는 파일들은 회사계정으로 git push, pull되게끔 설정

.gitconfig-work 파일 작성하기

[user]
    email = 회사깃헙계정메일주소
    name = 이름
[github]
user = 유저명

4. 확인해보기

개인계정

$ ssh -T git@personal Hi jeongmin14! You've successfully authenticated, but GitHub does not provide shell access.

회사계정

$ ssh -T git@work Hi miayoon14! You've successfully authenticated, but GitHub does not provide shell access.

5. git clone

이제 git clone할 때 ssh를 이용한다. $ git clone git@github.com:jeongmin14/algorithm.git에서 git@github.com 부분을 개인계정일 경우 git@personal로, 회사계정일 경우 git@work로 바꿔주기 (ssh/config에서 작성한 host로 바꿔주면 된다. ex)git@{host})

Exiting
/Users/jmin/.rbenv/versions/3.0.1/lib/ruby/gems/3.0.0/gems/puma-5.2.2/lib/puma/binder.rb:288:in `initialize': Address already in use - bind(2) for "127.0.0.1" port 3000 (Errno::EADDRINUSE)

오잉? 이미 사용이라고? 구글링ㄱㄱ

$ lsof -wni tcp:3000 입력하니깐 이게 나옴

$ kill -9 29768 하고 다시 서버켜주기!

참고

우선 ruby 버전 확인하기 $ ruby --version 아마 2.6?어쩌고 일거다. stable version으로 해주자

ruby 버전 관리자인 rbenv설치하기 $ brew update $ brew install rbenv

설치할 수 있는 ruby버전 확인하기 $ rbenv install -l 3.0.1설치~ $ rbenv install 3.0.1 $ rbenv rehash

ruby 버전 기본값을 3.0.1로 바꿔주기 $ rbenv local 3.0.1 $ rbenv global 3.0.1 버전확인해보기! $ ruby --version 아직도 2.6.어쩌구라면?! $ vim ~/.zshrc 열어서 맨 아래

eval "$(rbenv init -)"
export PATH="$HOME/.rbenv/bin:$PATH"

위 내용 추가한 후 :wq 끝~

Rails install

rbenv환경에는 bundler설치되어 있지않기때문에 설치해주기 $ gem install bundler 그 다음 rails 설치하기 $ gem install rails $ rbenv rehash $ rails -v 버전확인

project 생성하기

원하는 디렉토리안에서 $ rails new 프로젝트이름

서버구동하기

$ cd 프로젝트이름 $ rails server -d 뭔가 안된다면..? $ sqlite3 --version 없으면 설치하기 $ node --version 없으면 설치하기 $ yarn --version 설치하기! -> $ brew install yarn 이제 되겠지? 했는데 안됐음... 참고 $ rails webpacker:install 설치 what is webpacker?

다시 $ rails server -d 크롬창켜서 http://127.0.0.1:3000 들어가보면 짠~

갈길이 멀다...

rails guides

direct message

웹소켓, django channels

실시간 채팅을 구현하기 위해서 웹소켓을 사용해야했고 django에서 channels라는 라이브러리를 제공해준다.

websoket이란? 웹소켓은 프로토콜로서, 실시간으로 데이터를 양방향 통신을 할 수 있게 해주는 기술이다. 소켓이란 쉽게 생각해서 통신을 위한 통로라고 생각하면 된다. web환경은 필요한 정보를 http 기반으로 request를 보내면 response을 보내주는 단순한 프로토콜이다. http 프로토콜은 매 요청과 응답마자 연결을 수립하고 끊는 과정을 반복해야 했기 때문에 유사한 통신을 계속 주고받는 실시간 채팅 같은 기능을 하는데 있어 비효율적이다. http를 이용하여 실시간 통신의 문제를 해결하기 위해 html5부터 웹소켓이 등장했다.

웹소켓은 실시간 양방향 통신을 지원하며 한번 연결이 수립되면 클라이언트와 서버 모두 자유롭게 데이터를 보낼 수 있다. 채팅과 같은 연속적인 통신에 대해 계속 유사한 통신을 반복하지 않게 해주어 통신의 효율성도 개선하였다.

웹소켓 핸드쉐이크

핸드쉐이크는 한번의 http요청과 http요청으로 이루어져 있다. 핸드쉐이크가 끝나면 http 프로토콜을 웹소켓 프로토콜로 변환하여 통신을 하는 구조이다.

channels

channels는 django에서 HTTP프로토콜이 아닌 다른 프로토콜을 사용할 수 있게 해준다. 웹소켓은 프로토콜의 일종으로서 이를 사용하기 위해서 channels을 이용하게 된다. channels layer가 생겨 일반적인 HTTP메시지 외에도 웹소켓메시지도 처리할 수 있게 된다.

ASGI

ASGI(Asynchronous Server Gateway Interface)는WSGI(Web Server Gateway Interface)를 계승한 것으로 비동기 방식으로 실행된다. 웹 서버와 python 응용프로그램 간의 표준 인터페이스를 제공하기 위해 Django Channels와 배포에 사용되는 Daphne 서버에서 정의한 사양으로서 HTTP, HTTP/2 및 WebSocket와 같은 프로토콜을 지원한다. ASGI는 비동기 요청인 웹 소켓을 처리하는 이벤트로서 connect, send, receive, disconnect가 있다.

전체적인 flow 장고 프로젝트 생성 -> 앱 생성(direct_message) -> channels 라이브러리 설치 -> settings.py의 installes_apps 맨 위에 추가하기 -> consumers.py 작성

import json

from channels.generic.websocket import AsyncWebsocketConsumer

from direct_messages.models     import DirectMessage, DirectMessageAttachFiles, Room
from users.models               import User
from decorators                 import login_check


class ChatConsumer(WebsocketConsumer):
    def connect(self):
        self.accept()

    def disconnect(self, close_code):
        pass


    # Receive message from WebSocket
    def receive(self, text_data):
        data         = json.loads(text_data)
        message      = data['message']
        user_account = data['user_account']
        room_name    = data['room_name']
        rooms        = Room.objects.filter(name__contains=user_account)

        self.send(data=json.dumps({'message':message}))

-> routing.py 추가 -> channel layer 구현하기

channel layer란?

의사소통 시스템이다. 즉 많은 소비자들 더 나아가서 django의 다른 부분과 의사소통을 할 수 있게 해준다. channel layer에는 두 가지 개념이 존재한다.

channel channel은 메시지를 보낼 수 있는 우편함이라고 생각하면 된다. 각 채널은 고유한 이름이 있으며 누구든지 채널에 메시지를 보낼 수 있다.

group group은 채널과 관련된 그룹이다. 그룹도 마찬가지로 이름을 가지며 그룹 이름을 가진 사용자는 누구나 그룹에 채널을 추가, 삭제 가능하고 그룹의 모든 채널에게 메세지를 보낼 수 있다. 그러나 그룹에 속한 채널을 나열 할 수는 없다.

소비자들은 채널 이름을 하나씩 가지고 있으며 channel layer를 통해 메시지를 주고 받을 수 있다.

channel layer 구현하기 $ brew install redis redis 설치하기 $ redis-server redis-server 돌려주기 $ pip install channels_redis channels 가 redis 인터페이스를 얻을 수 있도록 channels_redis 패키지를 설치

-> settings.py에서 channel layer 설정하기

# Channels
ASGI_APPLICATION = 'instamg.asgi.application'
CHANNEL_LAYERS = {
    'default': {
        'BACKEND': 'channels_redis.core.RedisChannelLayer',
        'CONFIG': {
            "hosts": [('127.0.0.1', 6379)],
        },
    },

-> consumers.py 추가하기 -> consumers.py 비동기식으로 작성하기

consumer를 비동기식으로 작성하게 되면 요청을 처리할 때, 추가적인 스레드를 생성하지 않는다. 즉 성능개선을 불러올 수 있다. 실시간 채팅같은 경우 성능이 굉장히 중요하기 때문에 이 과정이 필요하다. sync_to_async를 통해서 django 코드를 비동기적으로 바꿀 수 있지만 async-native라이브러리보다 성능이 떨어진다.

ChatConsumer가 상속받는 것이 WebsocketConsumer 에서 AsyncWebsocketConsumer 으로 바뀌었다. 또한 메소드 선언 시, async 가 붙고, 메소드를 호출 하는 경우에도 await 를 붙여서 비동기 처리를 했다.

Database Access Django ORM은 동기식 코드이기 때문에 위와 같이 consumer를 비동기식으로 작성한 상태에서 접근하기 위해서는 해줘야할 작업이 있다.

# database_sync_to_async import 해주기
from channels.db  import database_sync_to_async

    @database_sync_to_async
    def create_message(self, user_account, message, rooms, room_name):
        if len(rooms) > 0:
            talked_user = sorted(room_name.split(user_account))[-1]
            for room in rooms:
                if talked_user in room.name and user_account in room.name:
                    room_name = room.name

        if not Room.objects.filter(name=room_name).exists():
            Room.objects.create(
                name = room_name
            )

        return DirectMessage.objects.create(
            room_id = Room.objects.get(name=room_name),
            user_id = User.objects.get(account=user_account),
            message = message
            )

    @database_sync_to_async
    def get_created_at(self):
        return DirectMessage.objects.last().created_at

 # 데코레이터로 사용하기 @database_sync_to_async

MySQL

SQL에서의 "Hello World"

select * from <테이블명>; //*은 모든 컬럼(열)을 의미한다.

select id, name from users; //users테이블에서 id, name 가져오기
// 지정한 컬럼 순서대로 표시됨(id, name)

where 조건문

select * from <테이블명> where <조건>;
// 조건식을 만족한(참) 행만 결과값으로 반환한다.

select * from users where name='서진호';
select * from users where birthdate='1980-07-08';
select * from users where country_id=6;
select * from users where country_id<>1;
//문자열형, 시간날짜형은 ' '으로 감싸기
// = 같다, <>같지않다

select * from users where profile_photo is null;
// null값을 검색할 경우 is null쓰기!

select * from users where profile_photo=null; //잘못된 예
Empty set (0.00 sec)

and, or 조합하기

and 먼저 계산됨

select * from users where gender='여자' or country_id<>1 and is_email_valid=1;

//(country_id<>1 and is_email_valid=1)먼저 실행한 뒤 
// or gender='여자' 실행
country_id가 1이 아니고 is_email_valid가 1인 user이거나 또는 gender='여자'인 경우

like 패턴 매칭

select * from users where name like '김%';
// name컬럼에 '김'이 들어간(매칭되는) 데이터 검색

?% 전방일치 %?% 중간일치 %? 후방일치

order by 정렬하기

select * from <table명> where <조건식> order by <컬럼명>;
// 지정된 커럼명에 따라 행 순서가 변경된다. default 오름차순

select * from users where gender='여자' order by birthdate;
// 여자 users를 생년월일 오름차순(나이많은->젊은)으로 정렬
select * from users where gender='여자' order by birthdate desc; // 내림차순 정렬

desc 내림차순 asc 오름차순 null값인 경우, 가장 작은 값으로 취급한다.

복수 정렬

select * from <table명> order by <컬럼1>, <컬럼2>;
// 먼저 <컬럼1>로 정렬한 뒤 <컬럼2> 정렬
// order by <컬럼1>, <컬럼2>와 order by <컬럼2>, <컬럼1>는 다름

limit 결과 행 제한하기

select <컬럼명> from <table명> limit <표시할 행 수>[offset 시작행];
// offset에 의한 시작 위치 지정은 limit뒤에 기술한다.
// '시작할 행-1'기억하기! ex)첫 번째 행부터 5개씩 가져온다면 1-1로 위치는 0이 되어 offset은0으로 지정하면 된다.
// ~limit 5 (offset0은 생략가능);
// ~limit 5 offset5; ->6번째 행부터 5개씩 정렬

select <컬럼명> from <table명> where <조건식> order by <컬럼명> limit <표시할 행 수>;
// limit은 반환할 행수를 제한하는 기능, where구로 검색한 뒤 order by로 정렬한 뒤에 최종적으로 처리된다.

서버내부 처리 순서 where구 -> select구 -> order by구

수치 연산

컬럼명이 id, price, quantity인 table1이 있다.

select *, price*quantity as '금액' from table1;
// price*quantity, 가격과 수량을 곱한 값을 새로운 컬럼 생성
// 연산하여 생긴 컬럼은 as와 함께 별명을 붙일 수 있다.(as생략가능)

round 함수

round()를 이용하여 반올림하기, 기본적으로 소수점 첫째 자리를 기준으로 반올림한 값을 반환한다.

select amount, round(amount, 1) from table1;
// amount열에 있는 값들을 소수점 둘째자리에서 반올림

문자열 연산

concat()를 이용하여 단위 연결하기

mysql> select *, concat(quantity,unit) as du from sample35;
+------+-------+----------+------+-------+
| no   | price | quantity | unit | du    |
+------+-------+----------+------+-------+
|    1 |   100 |       10 | 개   | 10개  |
|    2 |   230 |       24 | 통   | 24통  |
|    3 |  1980 |        1 | 장   | 1장   |
+------+-------+----------+------+-------+

substring()은 문자열의 일부분을 계산해서 반환해주는 함수이다.

mysql> select id,name,birthdate,substring(birthdate,1,4) as year from users where name='조경숙';
+----+-----------+------------+------+
| id | name      | birthdate  | year |
+----+-----------+------------+------+
|  5 | 조경숙    | 2017-06-25 | 2017 |
+----+-----------+------------+------+

trim()은 문자열의 앞뒤로 여분의 스페이스가 있을 경우 이를 제거해주는 함수이다. character_length()는 문자열의 길이를 계산하여 반환해주는 함수이다. char_length()로 줄여서 쓸 수 있다.

case문으로 데이터 변환하기

case when <조건식1> then <식1> [when <조건식2> then <식2>] [else <식3>] end

when에는 참과 거짓을 반환할 수 있는 조건식을 쓴다. when절이 참일 경우 then절에 쓰인 식이 처리된다. 조건절에 만족하지 못할 경우 else에 쓰인 식이 처리됨(else가 생력되어 있을 경우 null값으로 처리됨)

mysql> select id, title, story_profile, case when story_profile=1 then "저장" else "저장안함" end as "저장여부" from stories limit 5;

select <컬럼명> ,case <조건문이 쓰일 컬럼명> when <조건식> then <식> else <식2> end as <지정할 컬럼명> from <테이블명>;

mysql> select id, title, story_profile, case story_profile when 1 then "저장" else "저장안함" end as "저장여부" from stories limit 5;
+----+------------------------+---------------+--------------+
| id | title                  | story_profile | 저장여부     |
+----+------------------------+---------------+--------------+
|  1 | 성현님 생일파티        |             0 | 저장안함     |
|  2 | 화이링!                |             0 | 저장안함     |
|  3 | 화이링!                |             0 | 저장안함     |
|  4 | 우리팀 화이링!         |             1 | 저장         |
|  5 | story save!            |             1 | 저장         |
+----+------------------------+---------------+--------------+

coalesce

null값을 변환하는 경우 쓰이는 식

mysql> select * from sample37;
+------+
| a    |
+------+
|    1 |
|    2 |
| NULL |
+------+

mysql> select a,coalesce(a,0) as"null값 바꾸기" from sample37;
+------+-------------------+
| a    | null값 바꾸기     |
+------+-------------------+
|    1 |                 1 |
|    2 |                 2 |
| NULL |                 0 |
+------+-------------------+

REST의 정의 : Representation State Transfer의 약자

자원의 이름(자원의 표현)으로 구분하여 해당 자원의 상태(정보)를 주고 받는 모든 것을 의미한다. 자원(resource) : 해당 소프트웨어가 관리하는 모든 것(문서, 그림, 데이터 등) 상태(정보) 전달 : 데이터가 요청되어지는 시점에서 자원의 정보를 전달한다.

REST의 구체적인 개념

HTTP URI(Uniform Resource Identifier)를 통해 자원(Resource)을 명시하고, HTTP Method(POST, GET, PUT, DELETE)를 통해 해당 자원에 대한 CRUD 기능을 적용하는 것을 의미한다.

구성요소

1. 자원(resource) : URI
2. 행위 : HTTP 프로토콜의 Method를 사용한다.
3. 표현 : client가 자원의 상태(정보)에 대한 조작을 요청하면 server는 이에 적절한 응답을 보낸다. REST에서 하나의 자원은 JSON, XML, TEXT, RSS 등 여러형태의 응답으로 나타내어 질 수 있다.(JSON으로 데이터를 주고 받는 것이 일반적이다.)

장점

• HTTP 프로토콜의 인프라를 그대로 사용하므로 REST API 사용을 위한 별도의 인프라를 구축할 필요가 없다.
• REST API 메시지가 의도하는 바를 명확하게 나타내므로 의도하는 바를 쉽게 파악할 수 있다.
• 서버와 클라이언트의 역할을 명확하게 구분한다.

단점

• 표준이 존재하지 않는다.
• 사용할 수 있는 메소드가 4가지 밖에 없다.(HTTP method 형태가 제한적)

REST가 필요한 이유

• 애플리케이션 분리 및 통합
• 다양한 클라이언트의 등장
• 죄근의 서버 프로그램은 다양한 브라우저와 안드로이폰, 아이폰과 같은 모바일 디바이스에도 통신을 할 수 있어야 한다.

REST 특징

1. Server-Client(서버-클라이언트 구조)
2. Stateless(무상태)
3. Cacheable(캐시 처리 가능)
4. Layered System(계층화)
5. Code-On-Demand(optional)
6. Uniform Interface(인터페이스 일관성)

REST API

API란?

데이터와 기능의 집합을 제공하여 컴퓨터 프로그램간 상호작용을 촉진하며, 서로 정보를 교환가능 하도록하는것

REST API의 정의 : REST 기반으로 서비스 API를 구현한 것

REST API의 특징

• REST 기반으로 시스템을 분산해 확장성과 재사용성을 높여 유지보수 및 운용을 편리하게 할 수 있다.
• REST는 HTTP 표준으로 기반으로 구현하므로, HTTP를 지원하는 프로그램 언어로 클라이언트, 서버를 구현할 수 있다.

RESTful API 설계시 주의할 점

• url는 정보의 자원을 표현해야한다.(resource명은 동사보다 명사로 사용)
• 자원에 대한 행위는 HTTP Method(GET, POST, PUT, DELETE 등)으로 표현
• 슬래시(/)는 계층관계를 나타내는데 사용, uri마지막 문자로 포함하지 않는다.
• 하이픈(-)운 uri 가독성을 높이는데 사용
• uri 경로에는 소문자가 적합하다.
• 파일확장자는 uri에 포함하지 않는다.

그래서 RESTful한 API뭔데???

이해하기 쉽고 사용하기 쉬운 api를 restful한 api라고한다.

댓글생성이 성공하면 success message와 comment data를 함께준다면 가능하지 않을까..?

from django.http  import JsonResponse, HttpResponse

.
.
.
class CommentView(View):
    @login_check
    def post(self, request, post_id):
        try:
            data = json.loads(request.body)

            if data.get('comment_id') is not None:
                comment_id = Comment.objects.get(id=data.get('comment_id'))
            else:
                comment_id = None

            Comment(
                post_id    = Post.objects.get(id=post_id),
                user_id    = request.user,
                content    = data['content'],
                comment_id = comment_id
            ).save() #생성된 댓글 저장

            comment_last = Comment.objects.last() #생성된 댓글 object
            comment_data = {
                'comment_id'      : comment_last.id,
                'comment_content' : data['content'],
                'user_account'    : request.user.account,
                'user_profile'    : "media/"+ str(request.user.thumbnail_path) if str(request.user.thumbnail_path) else None
            } #생성된 댓글 정보
            return HttpResponse(json.dumps({'message': 'SUCCESS', 'comment_data': comment_data}))
        except KeyError:
            return JsonResponse({'message':'KEY_ERROR'}, status=400)
        except Post.DoesNotExist :
            return JsonResponse({'message':'POST_DOES_NOT_EXIST'}, status=400)

return HttpResponse(json.dumps({'message': 'SUCCESS', 'comment_data': comment_data}))

HttpResponse로 보내줄 데이터들을 json.dumps에 싸서 보내주기???

{
    "message": "SUCCESS",
    "comment_data": {
        "comment_id": 913,
        "comment_content": "댓글달기 http다시도전 이번엔 제발",
        "user_account": "burgerqueen",
        "user_profile": "media/thumbnail/slackselfi_zPwpVQY.jpeg"
    }
}

참고

select_related 와 prefetch_related 는 하나의 QuerySet을 가져올 때, 미리 related objects들까지 다 불러와주는 함수이다.
그렇게 불러온 data들은 모두 cache에 남아있게 되므로 DB에 다시 접근해야 하는 수고를 덜어줄 수 있다. 이렇게 두 함수 모두 DB에 접근하는 수를 줄여, performance를 향상시켜준다는 측면에서는 공통점이 있지만, 그 방식에는 차이점이 있다.

예시모델

from django.db import models

class Publisher(models.Model):
    name = models.CharField(max_length=255)

    class Meta:
        db_table = 'publishers'

    def __str__(self):
        return self.name


class Book(models.Model):
    name = models.CharField(max_length=255)
    price = models.IntegerField(default=0)
    publisher = models.ForeignKey(Publisher, on_delete=models.CASCADE)

    class Meta:
        db_table = 'books'

    def __str__(self):
        return self.name


class Store(models.Model):
    name = models.CharField(max_length=255)
    books = models.ManyToManyField(Book)

    class Meta:
        db_table = 'stores'

    def __str__(self):
        return self.name

select_related

select_related는 쿼리셋을 반환할 때 foreign-key, OneToOne관계인 모델을 가져오는 ORM이다. (SQL의 JOIN을 사용함)

정참조(OneToMany관계)에서 DB hit 줄이는 방법

views.py(select_related 적용 전)

class BooksWithAllMethodView(View):
    def get(self, request):
        queryset = Book.objects.all()

        books = []
        for book in queryset:  # queryset 평가
            books.append({
                'id': book.id,
                'name': book.name,
                'publisher': book.publisher.name # book.publisher에 접근, 캐싱되지 않은 데이터이므로 query 발생
                }
            )
        return JsonResponse({'books_with_all_method' : books }, status=200)

실행된 쿼리문

SELECT books.id, books.name, books.price, books.publisher_id
FROM books 

SELECT publishers.id, publishers.name
FROM publishers
WHERE publishers.id = 1

SELECT publishers.id, publishers.name
FROM publishers
WHERE publishers.id = 1

SELECT publishers.id, publishers.name
FROM publishers
WHERE publishers.id = 1

...

Book 모델에서 data를 가져오는 쿼리 1개 Book모델에 걸려있는 publishers모델을 가져오는 쿼리(book의 개수만큼 쿼리 발생)

views.py(select_related 적용 후)

class BooksWithSelectRelatedView(View):
    def get(self, request):
        queryset = Book.objects.select_related("publisher").all()

        books = []
        for book in queryset:  # queryset 평가
            books.append({
                'id': book.id,
                'name': book.name,
                'publisher': book.publisher.name
                }
            )
        return JsonResponse({'books_with_all_method' : books }, status=200)

실행된 쿼리문

SELECT books.id, books.name, books.price, books.publisher_id, publishers.id, publishers.name 
FROM books 
INNER JOIN publishers 
ON books.publisher_id = publishers.id

select_related는 INNER JOIN으로 data를 가져오기 때문에 쿼리문 하나로 해결가능!

prefetch_related

prefetch_related은 foreign-key, OneToOne뿐만 아니라 ManyToMany, ManyToOne등 모든 관계에서 쓰일 수 있다.

역참조(Many-To-Many 관계) 상황에서 DB hit 줄이는 방법

views.py(prefetch_related 적용 전)

class StoresWithAllMethodView(View):
    def get(self, request):
        queryset = Store.objects.all()

        stores = []
        for store in queryset:  # 쿼리셋 평가
            books = [book.name for book in store.books.all()]  # 각 store마다 books로 접근, 쿼리 발생
            stores.append({
                'id': store.id,
                'name': store.name,
                'books': books
                }
            )
        return JsonResponse({'stores_with_all_method' : stores }, status=200)

실행된 쿼리문

SELECT stores.id, stores.name
FROM stores;

SELECT books.id, books.name, books.price, books.publisher_id
FROM books 
INNER JOIN stores_books 
ON books.id = stores_books.book_id 
WHERE stores_books.store_id = 1

SELECT books.id, books.name, books.price, books.publisher_id
FROM books 
INNER JOIN stores_books 
ON books.id = stores_books.book_id 
WHERE stores_books.store_id = 1

SELECT books.id, books.name, books.price, books.publisher_id
FROM books 
INNER JOIN stores_books 
ON books.id = stores_books.book_id 
WHERE stores_books.store_id = 1

SELECT books.id, books.name, books.price, books.publisher_id
FROM books 
INNER JOIN stores_books 
ON books.id = stores_books.book_id 
WHERE stores_books.store_id = 1

...

views.py(prefetch_related 적용 후)

class StoresWithPrefetchRelatedView(View):
    def get(self, request):
        queryset = Store.objects.prefetch_related("books").all()

        stores = []
        for store in queryset:
            books = [book.name for book in store.books.all()]
            stores.append({'id': store.id, 'name': store.name, 'books': books})

        return JsonResponse({'stores_with_prefetch_related' : stores }, status=200)

실행된 쿼리문

SELECT stores.id, stores.name
FROM stores;

SELECT stores_books.store_id, books.id, books.name, books.publisher_id 
FROM books 
INNER JOIN 
stores_books 
ON books.id = stores_books.book_id 
WHERE stores_books.store_id IN (1, 2, 3, 4, 10, 50, ....) ;

Store.objects.all() 이라는 쿼리가 실행되면서 동시에 store에 걸려있는 book의 data들이 cache에 저장된다. store의 수 만큼 book이 실행되더라도 DB에 접근하지 않고 cache에서 찾아서 쓰게 된다.

정리

prefetch_related은 원래의 main query가 실행된 후 별도의 query를 따로 실행하고 select_related은 하나의 query만으로 related objects들을 다 가져온다.

MTM MTO의 관계에서는 prefetch_related를 사용해야 하지만 foreign_key, OTO과 같은 single-valued 관계가 있는 곳에서는 최대한 select_related를 사용하여 query수를 줄여주는 것이 효과적!

Caching and QuerySets 참고 참고

pytz라이브러리는 datetime을 쉽게 다룰 수 있도록 도와준다.

pytz가 제공하는 시간대 식별자 확인하기

import pytz

for tz in pytz.all_timezones:
    print(tz)
   # 출력결과
   Africa/Abidjan
   Africa/Accra
   Africa/Addis_Ababa
   Africa/Algiers
   Africa/Asmara
   Africa/Asmera
   Africa/Bamako
   Africa/Bangui
   Africa/Banjul
   Africa/Bissau
   .
   .

settings.py에서 설정한 시간 출력

from datetime     import datetime
from pytz         import utc

now = datetime.now()
print(now) 
//2021-02-27 14:20:08.235438

Datetime

python에서 날짜와 시간은 표현하는 아주 유용한 패키지이다.

데이터베이스의 시간은 utc로 저장하고 데이커를 가지고올 때 timezone을 localtime으로 바꿔주는 것이 좋다.

django에서 프로젝트 settings.py에서 USE_TZ=true TIME_ZONE='Asia/Seoul'로 설정하기

Naive VS Aware

• Naive tzinfo 속성이 설정되지 않은 datetime 객체 (TIME_ZONE 변수로 지정한 시간대 사용)
• Aware tzinfo 속성이 설정된 datetime 객체 (명확하게 기준이 되는 시간대를 tzinfo 속성으로 지정)

USE_TZ 설정에 따른 차이

장고는 내부적으로 Aware datetime 객체를 사용한다. 즉 장고 개발 시 Aware datetime 객체를 사용해야 한다. (기준 시간대를 명확히 지정해줘야 함)

폼에 입력된 날짜 값은 Current time zone으로 해석한 뒤 Aware datetime 객체로 변환되고, 템플릿에 렌더링할 때는 Aware datetime 객체를 Current time zone으로 변환한다.

※ 만약 Naive datetime 객체를 사용하면 어떻게 될까?

하위호환성을 위해 Naive datetime 객체를 사용해도 문제가 없도록 설계가 되어 있다. 데이터베이스에 저장될 때 Naive datetime 객체를 Aware datetime 객체로 변환하고, 경고만 띄워준다. 하지만 그것도 DST 등으로 인한 문제가 발생할 여지는 있기 때문에, 항상 Aware datetime 객체를 사용하는 게 안전하다.

UTC -> localtime으로 바꿔서 보여주기

from datetime import datetime
from pytz import timezone

now_utc = datetime.now(timezone('UTC')) # 현재시간을 utc로 표시
now_kst = now_utc.astimezone(timezone('Asia/Seoul')) # utc를 kst로 변경

데이터베이스에 저장된 시간은 utc로 설정하고 데이터를 보여줄 때 한국시간으로 보여주기

# 기존코드 ,db에 저장된 그대로 나옴(utc)
"created_at"     : post.created_at
# 결과 
//“created_at”: “2021-03-06T07:55:02.563Z”,


# 한국시간으로 보여주기
"created_at"     : post.created_at.astimezone(timezone('Asia/Seoul'))
# 결과
//“local_created_at”: “2021-03-06T16:55:02.563+09:00",

참고 참고 참고 참고

mysql DB 백업

$ mysqldump -u root -p [DB명] > [생성할 백업DB명].sql $ mysqldump -u root -p [패스워드] [DB명] > [생성할 백업DB명].sql

ex $ mysqldump -u root instamg > instamg_v1.sql

화살표 방향에 주의할 것!

mysql table 백업

$ mysqldump -u root -p [DB명] [백업할 table명] > [생성할 백업table명].sql

ex $ mysqldump -u root -p instamg users > instamg_users.sql

복원하기

mysql DB 복원

$ mysql -u root -p [복원할 데이터베이스] < [백업한 데이터베이스].sql

ex $ mysql -u root -p instamg < instamg_vi.sql

mysql table 복원

$ mysql -u root -p [복원할 데이터베이스] < [백업한 테이블].sql

ex $ mysql -u root -p instamg < instamg_users.sql

앞에 mysql !!! mysqldump 🚫

복원할 때 해당 경로에 sql파일이 있어야 한다.

유저의 프로필 업데이트

• accout
• email
• password
• phone
• profile photo

form-data형식으로 데이터 받음

🙅🏻‍♀️ 오류코드

    @login_check
    def post(self, request):
        data  = json.loads(request.POST['json'])
        user = request.user
        PASSWORD_LENGTH = 8
        EMAIL_VALIDATOR = re.compile(r"[a-z0-9!#$%&'*+/=?^_`{|}~-]+(?:\.[a-z0-9!#$%&'*+/=?^_`{|}~-]+)*@(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\.)+[a-z0-9](?:[a-z0-9-]*[a-z0-9])?")
        new_password = data.get('new_password')
        new_account = data.get('new_account')
        new_phone = data.get('new_phone')
        new_email = data.get('new_email')

        # 생략(account 변경)

        # 생략(email 변경)

        # 생략(phone 변경)

        # 생략(password 변경)

        if request.FILES.get('profile_photo'):
            print(request.FILES.get('profile_photo'))
            files = request.FILES['profile_photo']
            User.objects.filter(id = user.id).update(profile_photo=files, thumbnail_path=files)
            return JsonResponse({'message' : 'PROFILE_PHOTO_CHANGE_COMPLETE'})

ERROR MESSAGE

json형식으로 받는 데이터들은 문제없이 업데이트가 되나 파일을 받는 경우에 다음과 같은 에러메시지 발생함.

request.POST['json'] 대신에 request.POST.get('json') 을 사용하여 해결? ['json']을 이용하면 ‘json’에 해당하는 값을 리턴해 주는데 존재하지 않으면 KeyError를 발생시킨다.

dict에서 특정 key의 값을 얻는 다른 방법으로 .get('key') 가 있다. get을 써서 존재하지 않은 key일 경우 None을 반환해준다. 추가로 .get('key', 'defaultvalue') 와 같이 key 값이 없을 경우 default 값을 설정해 줄 수 있다.

🙅🏻‍♀️ 다른오류

    @login_check
    def post(self, request):
        data = json.loads(request.POST.get('json')) #.get을 사용
        new_password = data.get('new_password')
        new_account = data.get('new_account')
        new_phone = data.get('new_phone')
        new_email = data.get('new_email')
        .
        .
        .

ERROR MESSAGE

다시 생각해보니 당연히 오류가 날 수 밖에... 프로필 사진 업로드 시 'json'에는 값이 없으니 None이 나오지!

🙆🏻‍♀️ 해결

@login_check
    def post(self, request):
        user = request.user
        PASSWORD_LENGTH = 8
        EMAIL_VALIDATOR = re.compile(r"[a-z0-9!#$%&'*+/=?^_`{|}~-]+(?:\.[a-z0-9!#$%&'*+/=?^_`{|}~-]+)*@(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\.)+[a-z0-9](?:[a-z0-9-]*[a-z0-9])?")

        if request.POST.get('json') is not None:
            data = json.loads(request.POST.get('json'))
            new_password = data.get('new_password')
            new_account = data.get('new_account')
            new_phone = data.get('new_phone')
            new_email = data.get('new_email')

            if new_account:
                if User.objects.filter(account=new_account).exists():
                    return JsonResponse({'message' : 'ALREADY_IN_USE'}, status=400)
                User.objects.filter(id=user.id).update(account=new_account)
                return JsonResponse({'message' : 'ACCOUNT_CHANGE_COMPLETE'}, status=200)
                .
                .
                .
         if request.FILES.get('profile_photo'):
            print(request.FILES.get('profile_photo'))
            files = request.FILES['profile_photo']
            User.objects.filter(id = user.id).update(profile_photo=files, thumbnail_path=files)
            return JsonResponse({'message' : 'PROFILE_PHOTO_CHANGE_COMPLETE'})

조건문을 걸어줘서 None이 아닐경우 값을 변수에 저장해주기!

코드가 지저분?하지만 나중에 리팩토링 하는걸로..

같이 해결해준 연우님 준형님 압도적 감사!!ㅋㅋㅋ

🚫 오류 발생

폼데이터로 받는 파일데이터(참고로 이번 프로젝트에서 파일은 s3에 저장하는것이 아닌 mediafile로 저장)가 로컬에 저장이 안되는거임... db를 확인해보면 업데이트한 파일로 변경된것을 확인할 수 있으나 로컬엔 저장이 안되어있고 프론트와 통신해봤을 때 사진도 안뜨고..

filter가 안먹히는 건가해서 save로 바꿔줌

if request.FILES.get('profile_photo'):
                path = request.FILES['profile_photo']
                user=User.objects.filter(id = user.id)[0]
                user.profile_photo = path
                user.thumbnail_path = path
                user.save()
                return JsonResponse({'message' : 'PROFILE_PHOTO_CHANGE_COMPLETE'})

db에도 저장 잘되어있고 로컬에도 저장 잘되고 프론트와 통신했을 때도 사진이 잘 떴다.

그런데 에러가 안잡힌다.... To be continue....

• 필요한 데이터 post, user_pofile, user_account, post_content, 로그인한 유저가 계정주와 팔로우 한 사이인지TF, 댓글, 대댓글....

'comments'       : [{
                        'comment_id'    : comment.id,
                        'user_id'       : comment.user_id_id,
                        'account'       : comment.user_id.account,
                        'profile_photo' : comment.user_id.profile_photo,#"/media/"+ str(comment.user_id.thumbnail_path) if str(comment.user_id.thumbnail_path) else None,
                        'content'       : comment.content,
                        'created_at'    : comment.created_at,
                        'like_count'    : Like.objects.filter(comment_id_id=comment.id).count()
                    }for comment in post.comments.filter(comment_id_id=None)],
'recomments'     : [{
                        'recomment_id'  : comment.id,
                        'comment_id'    : comment.comment_id_id,
                        'user_id'       : comment.user_id_id,
                        'account'       : comment.user_id.account,
                        'profile_photo' : comment.user_id.profile_photo,#"/media/"+ str(comment.user_id.thumbnail_path) if str(comment.user_id.thumbnail_path) else None,
                        'content'       : comment.content,
                        'created_at'    : comment.created_at,
                        'like_count'    : Like.objects.filter(comment_id_id=comment.id).count(),
                    }for comment in post.comments.exclude(comment_id_id=None)],
 'file'          :[{
                                    'file_type'      : post_attach_file.file_type,
                                    "view_count"     : post_attach_file.view_count,
                                    'path'           : "/media/"+str(post_attach_file.path),
                                    'thumbnail_path' : "/media/"+str(post_attach_file.thumbnail_path)
                    }for post_attach_file in post.post_attach_files.all()]
            }
            return JsonResponse({'post':post}, status=200)
        except ValueError:
            return JsonResponse({'message':'VALUE_ERROR'}, status=400)
        except IndexError:
            return JsonResponse({'message':'POST_DOES_NOT_EXIST'}, status=400)

처음에 썼던 방법 비효율 적인 느낌👎

'comments'           : [{
                                        'comment_id'                 : comment.id,
                                        'content'                    : comment.content,
                                        'comment_user_id'            : comment.user_id.id,
                                        'comment_user_account'       : comment.user_id.account,
                                        'comment_user_profile_photo' : "/media/"+ str(comment.user_id.thumbnail_path) if str(comment.user_id.thumbnail_path) else None,
                                        'created_at'                 : comment.created_at,
                                        'like_count'                 : Like.objects.filter(id=comment.id).count(),
                                        'is_liked'                   : comment.likes.exists(),
      'recomment'                  :[{
                                            'comment_id'                   : comment.id,
                                            'recomment_id'                 : recomment.id,
                                            'content'                      : recomment.content,
                                            'recomment_user_id'            : recomment.user_id.id,
                                            'recomment_user_account'       : recomment.user_id.account,
                                            'recomment_user_profile_photo' : "/media/"+ str(recomment.user_id.thumbnail_path) if str(recomment.user_id.thumbnail_path) else None,
                                            'created_at'                   : recomment.created_at,
                                            'like_count'                   : Like.objects.filter(comment_id_id=comment.id).count(),
                                            'is_liked'                     : comment.likes.exists()
                } for recomment in Comment.objects.filter(comment_id=comment.id)]
            } for comment in post.comments.filter(comment_id=None)],

수정한 코드 comments 라는 배열안에 키값이 recomments인 배열을 가지고있음

인스타그램 개인 프로필에서 저장된 스토리 데이터 보여주기

class ProfileStoryView(View):
    def get(self, request, user_id):
        try:
            user    = User.objects.get(id = user_id)
            stories = []
            for story in user.story_set.all():
                if story.story_profile==1:
                    for files in story.storyattachfiles_set.all():
                        stories.append({
                            "story_id"  : story.id,
                            "title"     : story.title,
                            "file"      : files.path, # 나중에 thumbnail_path로 바꾸기
                            "file_type" : files.file_type
                        })
            return JsonResponse({"profile_story" : stories}, status = 200)
        except KeyError:
            return JsonResponse({"message" : "KEY_ERROR"}, status=400)

유저가 스토리를 생성하고나서 그 스토리를 본인의 프로필에 저장할 것인지 결정할 수 있다. 스토리 테이블에 story_profile컬럼을 만들어 저장안할 경우(불린값0) 저장할 경우 1

저장할 경우(불린값1)의 스토리만 보여주기

feature/기능 branch에서 기능구현 완료 후 (커밋필수!)

1. $ git checkoust main 메인 브랜치로 이동하여 main pull받기
2. 다시 작업했던 브랜치로 돌아와서$ git rebase -i main 하기
3. vim에서 오래된 commit은 pick하고 나머지는s(squash)하기
4. vim에서 커밋 메시지 작성

rebase중 충돌 있을 경우? 해당 코드로 가서 수정 후 git add . git rebase --continue반복하기 해결 안되면 git rebase --abort

5. rebase를 마쳤다면 push하기(작업중인 브랜치에서) $ git push origin <작업한 브랜치명> -f (git은 history가 다른 branch의 push를 허용하지 않는다. -f를 이용하여 강제로 푸쉬)

요약

• users, posts, stories direct messages 앱으로 구성

user를 product로 생각하면

• 리스트 : 팔로우한 계정 게시물
• 상세 페이지 : 개인 프로필(개인 인스타 계정)
• 디테일 페이지 : 개인 프로필에서 게시물 상세 조회

맡은 부분

• 좋아요
• 개인피드 조회
• 개인피드 게시물 상세 조회
• 개인피드 태그된 게시물 조회
• 스토리 조회

생각 할 부분

• 개인프로필 조회 시 데이터를 한번에 다 보내줘야 하는가? 👉🏻 프로필부분, 프로필에 저장한 스토리, 피드 데이터 따로 보내주는 게 RESTful함.
• 게시물 상세 조회에서 대댓글은 어떤 형태로 보여주지?
• 유저가 로그인 후 유저의 프로필인지, 유저가 팔로우한 프로필인지 아닌지 구분하기
• 스토리 조회 시 현재시간 기준으로 24시간내 생성된 게시물만 보여주기
• SSE(Server Sent Event)이용하여 실시간으로 좋아요, 팔로워, 팔로잉 수 업데이트하기
• WebSocket

새로운 부분

• s3이용하여 이미지 저장하는 것이 아닌 로컬에서 저장하기
• 이미지 업로드 시 썸네일도 같이 업로드, 이미지크기변환
• 실시간 기능

🐻 BearBnB Team Project 🐻

💁🏻‍♀️ Bearbnb Github

프론트엔드

백엔드

💁🏻‍♀️ Team Member

Frontend : 정민선(PM), 태성현, 김승완

Backend : 윤정민, 김건희, 홍연우

💁🏻‍♀️ Technologies

MySQL

Python

Django

Git

AWS : EC2, RDS, S3

Docker

JWT, Bcrpyt

googlemaps

Kakao API

django-seed

💁🏻‍♀️ Modeling

💁🏻‍♀️ Functions

회원가입, 비밀번호 암호화(bcrypt) 로그인, token 발행(JWT) 소셜 로그인, kakao API 전체 리스트, pagination, 필터링 location 위도 경도 변환 상세 페이지 뷰 예약하기, SMTP 사용 호스팅 Project Result BearBnB 결과물

💁🏻‍♀️ 데모영상

youtube 영상

💁🏻‍♀️ Reference

이 프로젝트는 airbnb 사이트를 참조하여 학습목적으로 만들었습니다. 실무수준의 프로젝트이지만 학습용으로 만들었기 때문에 이 코드를 활용하여 이득을 취하거나 무단 배포할 경우 법적으로 문제될 수 있습니다. 이 프로젝트에서 사용하고 있는 사진 대부분은 위코드에서 구매한 것이므로 해당 프로젝트 외부인이 사용할 수 없습니다.

"CORS configuration" 버튼을 눌러서 CORS 설정을 해주도록 하자. 위에 설명은 XML형식이므로 JSON형식으로 바꿔서 설정해주기

[
    {
        "AllowedHeaders": [
            "*"
        ],
        "AllowedMethods": [
            "GET"
        ],
        "AllowedOrigins": [
            "*"
        ],
        "ExposeHeaders": [
            "ETag"
        ],
        "MaxAgeSeconds": 3000
    }
]

Django에서 boto3를 사용하여 S3와 연결 및 파일 업로드

터미널에서 boto3설치하기 $ pip install boto3

# django 앱 views.py
import boto3
from django.http import HttpResponse

import해주기!

class FileView(View):
    s3_client = boto3.client(
        's3',
        aws_access_key_id="s3세팅 시 설치한new_user_credentials에 있는 키ID",
        aws_secret_access_key="s3세팅 시 설치한new_user_credentials에 있는 키"
    )

    def post(self, request):
        file = request.FILES['filename'] #['키값']

        self.s3_client.upload_fileobj(
            file, 
            "wecode16", #버킷이름
            file.name,
            ExtraArgs={
                "ContentType": file.content_type
            }
        ) 

        return HttpResponse(status= 200)

url 설정

from users.views import FileView from <앱이름>.views import FileView

urlpatterns = [
    path("/file", FileView.as_view()),
]

postman 이용 시

HTTPie 이용 시

http -f POST 127.0.0.1:8000/user/file filename@~/Desktop/database.png http -f POST <ip 주소>/<url> <키값>@~/<업로드할 파일경로와 이름>

💁 enter cloud github

프론트엔드

백엔드

🚀 프로젝트 소개

1차 프로젝트 스페이스 클라우드를 모티브로 프로젝트를 진행했습니다.

2주라는 짧을 기간 제약이 있어 기획이 최소한으로 들어가는 사이트 클론 프로젝트를 선정했습니다. http method와 uri을 활용하여 restful 한 프로젝트를 지향합니다.

🚀 개발 방향

개발기간 : 2021/1/11 ~ 2020/1/22 ( 2주간 진행 )

매일 데일리 미팅과 Sprint기간을 1주일로 잡고 매주 한번씩 Sprint 미팅을 통해 에자일하게 프로젝트를 진행했습니다.

🚀 팀원

Front_end

• 김승완

• 문규찬

Back_end

• 김준형(PM)

• 윤정민

🚀 적용 기술 및 구현 기능

공통

• AWS EC2, RDS 를 이용하여 배포를 진행했고, nohup으로 백그라운드로 돌아가도록 설정
• Aquery Tool을 이용한 모델링

백엔드

• Python
• Django Framework
• Bcrypt를 이용한 단방향 해쉬 암호 저장, JWT Token을 이용한 유저 확인
• RDBS인 Mysql을 사용
• Django-seed를 활용한 커맨드를 만들어 가짜데이터로 통신을 주고 받음

🚀 페이지별 구현 항목

/signin, /signup

• Bcrypt, JWT를 활용한 로그인, 회원가입 기능 구현

/spaces

• 메인페이지와 리스트 페이지 등... 여러 곳에서 필요한 공간 카드는 따로 View를 만들어 관리

/likes

• 찜하기 기능, 찜한 공간 리스트 보여주기

데모 영상

youtube 영상

Reference

• 이 프로젝트는 스페이스 클라우드 (https://www.spacecloud.kr/) 사이트를 참조하여 학습목적으로 만들었습니다.
• 실무수준의 프로젝트이지만 학습용으로 만들었기 때문에 이 코드를 활용하여 이득을 취하거나 무단 배포할 경우 법적으로 문제될 수 있습니다.
• 이 프로젝트에서 사용하고 있는 사진 대부분은 위코드에서 구매한 것이므로 해당 프로젝트 외부인이 사용할 수 없습니다.

QuerySet 심화

1. select_related()

2. prefetch_related()

Field lookups

many to many ORM

python 삼항연산자

1. 메인 페이지 space 카드뷰 데이터 불러오기

spaces=Space.objects.all() many to many 또는 one to many로 연결된 데이터 가지고 오기

views.py에서 print(dir(space)) 입력해서 space객체가 쓸 수 있는 메소드 확인하기

<class명>_set 이용하여 many to many 또는 one to many로 연결된 데이터 가지고 오기

# 공간의 태그 가져오기
spaces = Space.objects.all()
for space in spaces:
    print(space.spacetag_set.all())
    for tag in space.spacetag_set.all():
    print(tag.tag.name)

# 공간의 타입 가져오기
for i in spaces:
    print(i.name) # 공간의 이름
    for space_type in i.types.all(): #공간과 mtm로 연결된 타입을 모두 호출
    print(space_type.name) #공간의 타입의 이름

python shell에서 연습해서 데이터를 불러올 수 있으면 views.py에 코드를 작성할 차례!

many to many 또는 one to many로 연결된 데이터를 가지고 오기 위해서는 for문이 두 번 돌아야 함 이럴 경우 list comprehension 이용하여 코드작성하기

list comprehension [(변수를 활용할 값) for (사용할 변수 이름) in (순회할 수 있는 값)]

# spaces/views.py
spaces=Space.objects.all()
data=[]
for space in spaces:
    data.append(
    {
"tag"   = [tag.tag.name for tag in space.spacetag_set.all()]

"types" = [space_type.name for space_type in space.types.all()]
    }
)
return JsonResponse({"data":data}, status = 201)

list comprehension사용하여 코드 리팩토링

data라는 빈 리스트를 선언하여 데이터 요소들을 append 하여 리스트에 추가하는 방법으로 작성한 코드를 list comprehension을 사용하여 코드를 줄일 수 있다.

# spaces/views.py
spaces=Space.objects.all()
data = [
    {
        "tag"   = [tag.tag.name for tag in space.spacetag_set.all()]
        "types" = [space_type.name for space_type in space.types.all()]
    }
    for space in spaces
    ]
return JsonResponse({"data":data}, status = 201)

2. aggregate

aggregation 공식문서 django database abstraction API

사용하기 전에 반드시 from django.db.models import Max,Avg import 할 것!

space와 one to many로 연결되어 있는 detailspace의 속성 "max_people"의 최대값을 구하기 <class명>.objects.all.aggregate(Max("속성")) 최대값 구하기 <class명>.objects.all.aggregate(Avg("속성")) 평균값 구하기

spaces.views.py

spaces = Space.objects.all()
results =  [
    {
        "max_people" = space.detailspace_set.all().aggregate(Max("max_people"))["max_people__max"]
    }
    for space in spaces:
    ]

# ["max_people__max"] 프론트에 데이터 보내줄 때 조금더 깔끔하게?보내주기위해, 딕셔너리형태?