def diaries_series(series_id):
"""시리즈별 다이어리 보여주는 API
"""
try:
db = None
user_id = 1
db = db_connector()
if db is None:
return jsonify(message="DATABASE_INIT_ERROR"), 500
diaries = model_dao.search_diaries_in_series(db, series_id, user_id)
diary=[
{
"diary_id": data['id'],
"emotion_id": data['emotion_id'],
"image_url":data['image_url'],
"color":data['color'],
"summary":data['summary'],
"like": True if data['is_deleted'] == 0 else False,
"is_public": True if data['public'] == 1 else False,
"count":model_dao.count_likes(db, data['id'])
}for data in diaries]
return jsonify(diary), 200
except Exception as e:
return jsonify(message=f"{e}"), 500
finally:
if db:
db.close()
def change_series_name(series_id):
"""시리즈 이름 변경 API
"""
try:
db = None
user_id = 1
name = request.json['name']
db = db_connector()
if db is None:
return jsonify(message="DATABASE_INIT_ERROR"), 500
db.begin()
model_dao.update_series_name(db, name, series_id)
db.commit()
return (''), 200
except Exception as e:
db.rollback()
return jsonify(message=f"{e}"), 500
finally:
if db:
db.close()
def select_diary(**kwargs):
"""다이어리 가져오기"""
db = None
try:
db = db_connector()
if db is None:
return jsonify(message="DATABASE_INIT_ERROR"), 500
diary = model_dao.select_diary(db, kwargs['id'], kwargs['diary_id'])
data = {
'emotion_id': diary['emotion_id'],
'series_id': diary['series_id'],
'contents': diary['contents'],
'summary': diary['summary'],
'is_completed': diary['is_completed'],
'public': diary['public']
}
return jsonify(data=data), 200
except pymysql.err.InternalError:
return jsonify(message="DATABASE_DOES_NOT_EXIST"), 500
except pymysql.err.OperationalError:
return jsonify(message="DATABASE_AUTHORIZATION_DENIED"), 500
except pymysql.err.ProgrammingError:
return jsonify(message="DATABASE_SYNTAX_ERROR"), 500
except pymysql.err.IntegrityError:
return jsonify(message="FOREIGN_KEY_CONSTRAINT_ERROR"), 500
except pymysql.err.DataError:
return jsonify(message="DATA_ERROR"), 400
except Exception as e:
return jsonify(message=f"{e}"), 500
finally:
if db:
db.close()
def find_user_series():
""" user별 시리즈 조회
"""
db = None
try:
user_id = 1
db = db_connector()
if db is None:
return jsonify(message="DATABASE_INIT_ERROR"), 500
series_data = model_dao.my_series(db, user_id)
data = [
{
"id": series['id'],
"name": series['name'],
"count": model_dao.count_series_diary(db, user_id, series['id'])
}for series in series_data ]
return jsonify(data), 200
except Exception as e:
return jsonify(message=f"{e}"), 500
finally:
if db:
db.close()
def check_if_email_exist():
"""이메일 중복 확인
Args:
email : 사용자의 이메일
"""
db = None
try:
db = db_connector()
if db is None:
return jsonify(message="DATABASE_INIT_ERROR"), 500
data = request.json
email = model_dao.search_email(db, data['email'])
if email:
return jsonify(message="EMAIL_ALREADY_EXIST"), 400
return jsonify(message="AVAILABLE_EMAIL"), 200
except pymysql.err.InternalError:
return jsonify(message="DATABASE_DOES_NOT_EXIST"), 500
except pymysql.err.OperationalError:
return jsonify(message="DATABASE_AUTHORIZATION_DENIED"), 500
except pymysql.err.ProgrammingError:
return jsonify(message="DATABASE_SYNTAX_ERROR"), 500
except pymysql.err.IntegrityError:
return jsonify(message="FOREIGN_KEY_CONSTRAINT_ERROR"), 500
except pymysql.err.DataError:
return jsonify(message="DATA_ERROR"), 400
except Exception as e:
return jsonify(message=f"{e}"), 500
finally:
if db:
db.close()
def check_if_nickname_exist():
"""닉네임 중복 확인
Args:
nickname : 사용자의 닉네임
"""
db = None
try:
db = db_connector()
if db is None:
return jsonify(message="DATABASE_INIT_ERROR"), 500
data = request.json
nickname = model_dao.search_nickname(db, data['nickname'])
if nickname:
return jsonify(message="NICKNAME_ALREADY_EXIST"), 400
return jsonify(message="AVAILABLE_NICKNAME"), 200
except pymysql.err.InternalError:
return jsonify(message="DATABASE_DOES_NOT_EXIST"), 500
except pymysql.err.OperationalError:
return jsonify(message="DATABASE_AUTHORIZATION_DENIED"), 500
except pymysql.err.ProgrammingError:
return jsonify(message="DATABASE_SYNTAX_ERROR"), 500
except pymysql.err.IntegrityError:
return jsonify(message="FOREIGN_KEY_CONSTRAINT_ERROR"), 500
except pymysql.err.DataError:
return jsonify(message="DATA_ERROR"), 400
except Exception as e:
return jsonify(message=f"{e}"), 500
finally:
if db:
db.close()
def delete_diary(**kwargs):
"""다이어리 삭제"""
db = None
try:
db = db_connector()
if db is None:
return jsonify(message="DATABASE_INIT_ERROR"), 500
db.begin()
model_dao.delete_diary(db, kwargs['id'], kwargs['diary_id'])
db.commit()
return '', 200
except pymysql.err.InternalError:
db.rollback()
return jsonify(message="DATABASE_DOES_NOT_EXIST"), 500
except pymysql.err.OperationalError:
db.rollback()
return jsonify(message="DATABASE_AUTHORIZATION_DENIED"), 500
except pymysql.err.ProgrammingError:
db.rollback()
return jsonify(message="DATABASE_SYNTAX_ERROR"), 500
except pymysql.err.IntegrityError:
db.rollback()
return jsonify(message="FOREIGN_KEY_CONSTRAINT_ERROR"), 500
except pymysql.err.DataError:
db.rollback()
return jsonify(message="DATA_ERROR"), 400
except Exception as e:
db.rollback()
return jsonify(message=f"{e}"), 500
finally:
if db:
db.close()
def new_series():
"""새로운 시리즈 생성 API
"""
db = None
try:
# user_id = 토큰에서 받아온 user_id
user_id = 1
name = request.json['name']
db = db_connector()
# db 에러처리
if db is None:
return jsonify(message="DATABASE_INIT_ERROR"), 500
series_id = model_dao.search_series(db, user_id, name)
# 시리즈 중복 확인
if series_id:
return jsonify(message="EXIST_SERIES"), 400
# db에 값 추가
db.begin()
model_dao.insert_series(db, user_id, name)
db.commit()
return (''), 200
except Exception as e:
db.rollback()
return jsonify(message=f"{e}"), 500
finally:
if db:
db.close()
def delete_series(series_id):
"""시리즈 삭제하는 API
"""
try:
db = None
user_id = 1
db = db_connector()
if db is None:
return jsonify(message="DATABASE_INIT_ERROR"), 500
db.begin()
model_dao.delete_series_from_db(db, series_id, user_id)
model_dao.delete_series_from_diaries(db, series_id, user_id)
db.commit()
return (''), 200
except Exception as e:
db.rollback()
return jsonify(message=f"{e}"), 500
finally:
if db:
db.close()
def delete_diary(series_id):
"""
시리즈에서 다이어리 삭제하는 API
"""
try:
db = None
user_id = 1
diaries = request.json['diary_id']
# requset body로 들어온 diary id를 tuple로 변경
diary_list = []
for diary in diaries:
diary_id = diary['id']
diary_list.append(diary_id)
diary_tuple = tuple(diary_list)
db = db_connector()
if db is None:
return jsonify(message="DATABASE_INIT_ERROR"), 500
db.begin()
model_dao.delete_diary_from_series(db, diary_tuple, user_id, series_id)
db.commit()
return (''), 200
except Exception as e:
db.rollback()
return jsonify(message=f"{e}"), 500
finally:
if db:
db.close()
def find_user_series(**kwargs):
"""user별 시리즈 조회.
Headers:
token
Return:
{data}, http status code
Exceptions:
InternalError: DATABASE가 존재하지 않을 때 발생
OperationalError: DATABASE 접속이 인가되지 않았을 때 발생
ProgramingError: SQL syntax가 잘못되었을 때 발생
IntegrityError: Key의 무결성을 해쳤을 때 발생
DataError: 컬럼 타입과 매칭되지 않는 값이 DB에 전달되었을 때 발생
KeyError: 엔드포인트에서 요구하는 키값이 전달되지 않았을 때 발생
"""
db = None
try:
user_id = kwargs['id']
db = db_connector()
if db is None:
return jsonify(message="DATABASE_INIT_ERROR"), 500
series_data = model_dao.my_series(db, user_id)
data = [{
"id":
series['id'],
"name":
series['name'],
"count":
model_dao.count_series_diary(db, user_id, series['id'])
} for series in series_data]
return jsonify(data), 200
except pymysql.err.InternalError:
return jsonify(message="DATABASE_DOES_NOT_EXIST"), 500
except pymysql.err.OperationalError:
return jsonify(message="DATABASE_AUTHORIZATION_DENIED"), 500
except pymysql.err.ProgrammingError:
return jsonify(message="DATABASE_SYNTAX_ERROR"), 500
except pymysql.err.IntegrityError:
return jsonify(message="FOREIGN_KEY_CONSTRAINT_ERROR"), 500
except pymysql.err.DataError:
return jsonify(message="DATA_ERROR"), 400
except KeyError:
return jsonify(message="KEY_ERROR"), 400
except Exception as e:
return jsonify(message=f"{e}"), 500
finally:
if db:
db.close()
def select_all_diaries(**kwargs):
"""
모든 다이어리 보기
---주석 지우면 안되요!!---
토큰값 없어서 임시로 주석 달아 놓음.
"""
db = None
try:
#user_id = kwargs['id']
# pagination 조건 생성
filter_dict = {}
filter_dict['limit'] = request.args.get('limit', 10, int)
filter_dict['offset'] = request.args.get('offset', 0, int)
filter_dict['emotion'] = request.args.getlist('emotion', int)
filter_dict['startdate'] = request.args.get('startdate')
filter_dict['enddate'] = request.args.get('enddate', datetime.today(),
str)
filter_dict['pop']
db = db_connector()
if db is None:
return jsonify(message="DATABASE_INIT_ERROR"), 500
all_diary_list = model_dao.search_all_diaries(db, filter_dict)
#like_count = model_dao.search_is_like(db, user_id)
all_diary = [
{
"nickname": diary['nickname'],
"diary_id": diary['id'],
"emotion_id": diary['emotion_id'],
"image_url": diary['image_url'],
"color": diary['color'],
"summary": diary['summary'],
#"like":True if model_dao.search_is_like(db, user_id, diary['id']) == 1 else False,
"count": model_dao.count_likes(db, diary['id'])
} for diary in all_diary_list
]
return jsonify(diary=all_diary), 200
except Exception as e:
return jsonify(message=f"{e}"), 500
finally:
if db:
db.close()
def sign_up():
"""이메일 회원가입
Args:
email : 사용자의 이메일
nickname : 사용자의 닉네임
password : 사용자의 비밀번호
"""
db = None
try:
db = db_connector()
if db is None:
return jsonify(message="DATABASE_INIT_ERROR"), 500
data = request.json
email = model_dao.search_email(db, data['email'])
if email:
return jsonify(message="EMAIL_EXIST"), 400
data['password'] = bcrypt.hashpw(data['password'].encode('utf-8'),
bcrypt.gensalt())
db.begin()
model_dao.create_user(db, data['email'], data['password'],
data['nickname'])
db.commit()
return '', 200
except pymysql.err.InternalError:
db.rollback()
return jsonify(message="DATABASE_DOES_NOT_EXIST"), 500
except pymysql.err.OperationalError:
db.rollback()
return jsonify(message="DATABASE_AUTHORIZATION_DENIED"), 500
except pymysql.err.ProgrammingError:
db.rollback()
return jsonify(message="DATABASE_SYNTAX_ERROR"), 500
except pymysql.err.IntegrityError:
db.rollback()
return jsonify(message="FOREIGN_KEY_CONSTRAINT_ERROR"), 500
except pymysql.err.DataError:
db.rollback()
return jsonify(message="DATA_ERROR"), 400
except Exception as e:
db.rollback()
return jsonify(message=f"{e}"), 500
finally:
if db:
db.close()
def question():
db = None
try:
db = db_connector()
if db is None:
return jsonify(message="DATABASE_INIT_ERROR"), 500
data = model_dao.search_question(db)
return jsonify(question=data), 200
except Exception as e:
return jsonify(message=f"{e}"), 500
finally:
if db:
db.close()
def sign_in():
"""이메일 로그인
Args:
email : 사용자의 이메일
password : 사용자의 비밀번호
Returns:
token : 로그인시 발행되는 JWT 토큰
"""
db = None
try:
db = db_connector()
if db is None:
return jsonify(message="DATABASE_INIT_ERROR"), 500
data = request.json
user = model_dao.search_email(db, data['email'])
if user:
if bcrypt.checkpw(data['password'].encode('utf-8'),
user['password'].encode('utf-8')):
token = jwt.encode(
{
'id': user['id'],
'exp': datetime.utcnow() + timedelta(hours=1)
}, SECRET_KEY, ALGORITHM).decode('utf-8')
return jsonify(token=token), 200
return jsonify(message="PASSWORD_DOES_NOT_MATCH"), 400
return jsonify(message="EMAIL_DOES_NOT_EXIST"), 400
except pymysql.err.InternalError:
return jsonify(message="DATABASE_DOES_NOT_EXIST"), 500
except pymysql.err.OperationalError:
return jsonify(message="DATABASE_AUTHORIZATION_DENIED"), 500
except pymysql.err.ProgrammingError:
return jsonify(message="DATABASE_SYNTAX_ERROR"), 500
except pymysql.err.IntegrityError:
return jsonify(message="FOREIGN_KEY_CONSTRAINT_ERROR"), 500
except pymysql.err.DataError:
return jsonify(message="DATA_ERROR"), 400
except Exception as e:
return jsonify(message=f"{e}"), 500
finally:
if db:
db.close()
def kakao():
""" kakao 로그인 API
"""
db = None
try:
token = request.headers['Authorization']
nickname = request.get_json(silent=True).get('nickname', None)
if not token:
return jsonify(message="TOKEN_DOES_NOT_EXIST"), 400
data = request.get('https://kapi.kakao.com/v2/user/me',
headers={'Authorization': f'Bearer {token}'})
kakao_id = data.json()['kakao_id']
db = db_connector()
if db is None:
return jsonify(message="DATABASE_INIT_ERROR"), 500
kakao_user = model_dao.search_kakao_user(db, kakao_id)
# 가입된 계정인 경우 로그인 진행
if kakao_user:
token = jwt.encode(kakao_user, SECRET_KEY, ALGORITHM)
return Jsonify(token=token.decode('utf-8'), nickname=nickname), 200
# 가입되어있지 않은 계정인 경우 회원가입 진행
elif kakao_user is None:
db.begin()
social_id = model_dao.insert_kakao_user(db, kakao_id)
if nickname:
kakao_user = model_dao.insert_kakao_into_user(
db, social_id, nickname)
token = jwt.encode(kakao_user, SECRET_KEY, ALGORITHM)
return Jsonify(token=token.decode('utf-8'),
nickname=nickname), 200
# 닉네임 입력하지 않은 경우 에러처리
elif nickname is None:
return jsonify(message="DATA_ERROR"), 400
db.commit()
except Exception as e:
db.rollback()
return jsonify(message=f"{e}"), 500
finally:
if db:
db.close()
def select_member_information(**kwargs):
db = None
try:
user_id = kwargs['id']
db = db_connector()
if db is None:
return jsonify(message="DATABASE_INIT_ERROR"), 500
data = model_dao.select_user_information(db, user_id)
return jsonify(data), 200
except Exception as e:
return jsonify(message=f"{e}"), 500
finally:
if db:
db.close()
def like_diary(**kwargs):
"""다이어리 좋아요"""
db = None
try:
db = db_connector()
if db is None:
return jsonify(message="DATABASE_INIT_ERROR"), 500
user_id = kwargs['id']
diary_id = kwargs['diary_id']
liked_diary = model_dao.search_id_like(db, user_id, diary_id)
db.begin()
if liked_diary:
model_dao.delete_liked_diary(db, user_id, diary_id)
return jsonify(message=False), 200
model_dao.like_diary(db, user_id, diary_id)
db.commit()
return jsonify(message=True), 200
except pymysql.err.InternalError:
db.rollback()
return jsonify(message="DATABASE_DOES_NOT_EXIST"), 500
except pymysql.err.OperationalError:
db.rollback()
return jsonify(message="DATABASE_AUTHORIZATION_DENIED"), 500
except pymysql.err.ProgrammingError:
db.rollback()
return jsonify(message="DATABASE_SYNTAX_ERROR"), 500
except pymysql.err.IntegrityError:
db.rollback()
return jsonify(message="FOREIGN_KEY_CONSTRAINT_ERROR"), 500
except pymysql.err.DataError:
db.rollback()
return jsonify(message="DATA_ERROR"), 400
except Exception as e:
db.rollback()
return jsonify(message=f"{e}"), 500
finally:
if db:
db.close()
def modify_diary(**kwargs):
"""다이어리 수정"""
db = None
try:
db = db_connector()
if db is None:
return jsonify(message="DATABASE_INIT_ERROR"), 500
data = request.json()
db.begin()
model_dao.update_diary(db, data['emotion_id'], data['series_id'],
data['contents'], data['summary'],
data['is_completed'], data['public'],
kwargs['id'], kwargs['diary_id'])
db.commit()
return '', 200
except pymysql.err.InternalError:
db.rollback()
return jsonify(message="DATABASE_DOES_NOT_EXIST"), 500
except pymysql.err.OperationalError:
db.rollback()
return jsonify(message="DATABASE_AUTHORIZATION_DENIED"), 500
except pymysql.err.ProgrammingError:
db.rollback()
return jsonify(message="DATABASE_SYNTAX_ERROR"), 500
except pymysql.err.IntegrityError:
db.rollback()
return jsonify(message="FOREIGN_KEY_CONSTRAINT_ERROR"), 500
except pymysql.err.DataError:
db.rollback()
return jsonify(message="DATA_ERROR"), 400
except KeyError:
db.rollback()
return jsonify(message="KEY_ERROR"), 400
except Exception as e:
db.rollback()
return jsonify(message=f"{e}"), 500
finally:
if db:
db.close()
def other_person_diary(**kwargs):
db = None
try:
users_id = kwargs['id']
db = db_connector()
if db is None:
return jsonify(message="DATABASE_INIT_ERROR"), 500
data_list = model_dao.other_person_diary(db, user_id)
other_person = [{
"nickname":
data['nickname'],
"diary_id":
data['id'],
"emotion_id":
data['emotion_id'],
"image_url":
data['image_url'],
"color":
data['color'],
"summary":
data['summary'],
"like":
True if model_dao.search_is_like(db, users_id, data['id']) == 1
else False,
"count":
model_dao.count_likes(db, data['id'])
} for data in data_list]
return jsonify(diary=other_person), 200
except Exception as e:
return jsonify(message=f"{e}"), 500
finally:
if db:
db.close()
def new_series(**kwargs):
"""새로운 시리즈 생성 API.
Headers:
Token
Args:
user_id: 사용자 id
name: 생성될 시리즈 이름
Return:
None
Exceptions:
InternalError: DATABASE가 존재하지 않을 때 발생
OperationalError: DATABASE 접속이 인가되지 않았을 때 발생
ProgramingError: SQL syntax가 잘못되었을 때 발생
IntegrityError: Key의 무결성을 해쳤을 때 발생
DataError: 컬럼 타입과 매칭되지 않는 값이 DB에 전달되었을 때 발생
KeyError: 엔드포인트에서 요구하는 키값이 전달되지 않았을 때 발생
"""
db = None
try:
# user_id = 토큰에서 받아온 user_id
user_id = kwargs['id']
name = request.json['name']
db = db_connector()
# db 에러처리
if db is None:
return jsonify(message="DATABASE_INIT_ERROR"), 500
# 시리즈 중복 확인
series_id = model_dao.search_series(db, user_id, name)
# 시리즈가 존재하면 Error
if series_id:
return jsonify(message="EXIST_SERIES"), 400
# db에 값 추가
db.begin()
model_dao.insert_series(db, user_id, name)
db.commit()
return (''), 200
except pymysql.err.InternalError:
db.rollback()
return jsonify(message="DATABASE_DOES_NOT_EXIST"), 500
except pymysql.err.OperationalError:
db.rollback()
return jsonify(message="DATABASE_AUTHORIZATION_DENIED"), 500
except pymysql.err.ProgrammingError:
db.rollback()
return jsonify(message="DATABASE_SYNTAX_ERROR"), 500
except pymysql.err.IntegrityError:
db.rollback()
return jsonify(message="FOREIGN_KEY_CONSTRAINT_ERROR"), 500
except pymysql.err.DataError:
db.rollback()
return jsonify(message="DATA_ERROR"), 400
except KeyError:
db.rollback()
return jsonify(message="KEY_ERROR"), 400
except Exception as e:
db.rollback()
return jsonify(message=f"{e}"), 500
finally:
if db:
db.close()
def modifying_member_information(**kwargs):
db = None
try:
data = request.json
user_id = kwargs['id']
db = db_connector()
if db is None:
return jsonify(message="DATABASE_INIT_ERROR"), 500
#회원 정보 변경 전 기존 비밀번호 확인
if bcrypt.checkpw(data['password'].encode('utf-8'),
kwargs['password'].encode('utf-8')):
#닉네임 검사 후 있는 닉네임이면 변경 불가
nickname = model_dao.search_nickname(db, data['nickname'])
if nickname:
return jsonify(message="NICKNAME_ALREADY_EXiST"), 400
#비밀번호를 변경 했다면 새 비밀번호와 닉네임 저장 후 새 토큰 발행
if data['new_password'] != None:
new_password = bcrypt.hashpw(
data['new_password'].encode('utf-8'), bcrypt.gensalt())
db.begin()
model_dao.put_user_information(db, data['nickname'],
new_password, user_id)
db.commit()
#새 토큰 발행
new_user = model_dao.search_email(db, kwargs['email'])
token = jwt.encode(
{
'id': new_user['id'],
'exp': datetime.utcnow() + timedelta(hours=1)
}, SECRET_KEY, ALGORITHM).decode('utf-8')
return jsonify(token=token), 200
#닉네임만 변경했을 때
else:
db.begin()
model_dao.put_user_nickname(db, data['nickname'], user_id)
db.commit()
return (''), 200
#기존 비밀번호 틀렸을 때
return jsonify(message="PASSWORD_DOES_NOT_MATCH"), 400
except pymysql.err.InternalError:
return jsonify(message="DATABASE_DOES_NOT_EXIST"), 500
except pymysql.err.OperationalError:
return jsonify(message="DATABASE_AUTHORIZATION_DENIED"), 500
except pymysql.err.ProgrammingError:
return jsonify(message="DATABASE_SYNTAX_ERROR"), 500
except pymysql.err.IntegrityError:
return jsonify(message="FOREIGN_KEY_CONSTRAINT_ERROR"), 500
except pymysql.err.DataError:
return jsonify(message="DATA_ERROR"), 400
except Exception as e:
return jsonify(message=f"{e}"), 500
finally:
if db:
db.close()
def diaries_series(**kwargs):
"""시리즈별 다이어리 보여주는 API.
Headers:
token
Args:
series_id: 시리즈 id
Return:
{diary}, http status code
Exceptions:
InternalError: DATABASE가 존재하지 않을 때 발생
OperationalError: DATABASE 접속이 인가되지 않았을 때 발생
ProgramingError: SQL syntax가 잘못되었을 때 발생
IntegrityError: Key의 무결성을 해쳤을 때 발생
DataError: 컬럼 타입과 매칭되지 않는 값이 DB에 전달되었을 때 발생
KeyError: 엔드포인트에서 요구하는 키값이 전달되지 않았을 때 발생
"""
db = None
try:
user_id = kwargs['id']
series_id = kwargs['series_id']
db = db_connector()
if db is None:
return jsonify(message="DATABASE_INIT_ERROR"), 500
diaries = model_dao.search_diaries_in_series(db, series_id, user_id)
diary = [{
"diary_id": data['id'],
"emotion_id": data['emotion_id'],
"image_url": data['image_url'],
"color": data['color'],
"summary": data['summary'],
"like": True if data['is_deleted'] == 0 else False,
"is_public": True if data['public'] == 1 else False,
"count": model_dao.count_likes(db, data['id'])
} for data in diaries]
return jsonify(diary), 200
except pymysql.err.InternalError:
return jsonify(message="DATABASE_DOES_NOT_EXIST"), 500
except pymysql.err.OperationalError:
return jsonify(message="DATABASE_AUTHORIZATION_DENIED"), 500
except pymysql.err.ProgrammingError:
return jsonify(message="DATABASE_SYNTAX_ERROR"), 500
except pymysql.err.IntegrityError:
return jsonify(message="FOREIGN_KEY_CONSTRAINT_ERROR"), 500
except pymysql.err.DataError:
return jsonify(message="DATA_ERROR"), 400
except KeyError:
return jsonify(message="KEY_ERROR"), 400
except Exception as e:
return jsonify(message=f"{e}"), 500
finally:
if db:
db.close()
def delete_series(**kwargs):
"""시리즈 삭제하는 API.
Header:
token
Args:
series_id: 시리즈 id
Return:
None
Exceptions:
InternalError: DATABASE가 존재하지 않을 때 발생
OperationalError: DATABASE 접속이 인가되지 않았을 때 발생
ProgramingError: SQL syntax가 잘못되었을 때 발생
IntegrityError: Key의 무결성을 해쳤을 때 발생
DataError: 컬럼 타입과 매칭되지 않는 값이 DB에 전달되었을 때 발생
KeyError: 엔드포인트에서 요구하는 키값이 전달되지 않았을 때 발생
"""
db = None
try:
user_id = kwargs['id']
series_id = kwargs['series_id']
db = db_connector()
if db is None:
return jsonify(message="DATABASE_INIT_ERROR"), 500
db.begin()
# 시리즈 삭제
model_dao.delete_series_from_db(db, series_id, user_id)
# 다이어리에서 해당 시리즈 삭제
model_dao.delete_series_from_diaries(db, series_id, user_id)
db.commit()
return (''), 200
except pymysql.err.InternalError:
db.rollback()
return jsonify(message="DATABASE_DOES_NOT_EXIST"), 500
except pymysql.err.OperationalError:
db.rollback()
return jsonify(message="DATABASE_AUTHORIZATION_DENIED"), 500
except pymysql.err.ProgrammingError:
db.rollback()
return jsonify(message="DATABASE_SYNTAX_ERROR"), 500
except pymysql.err.IntegrityError:
db.rollback()
return jsonify(message="FOREIGN_KEY_CONSTRAINT_ERROR"), 500
except pymysql.err.DataError:
db.rollback()
return jsonify(message="DATA_ERROR"), 400
except KeyError:
db.rollback()
return jsonify(message="KEY_ERROR"), 400
except Exception as e:
db.rollback()
return jsonify(message=f"{e}"), 500
finally:
if db:
db.close()
def kakao():
"""kakao 로그인 API.
Header:
Authorizaion
Args:
nickname: 사용자의 닉네임
Kakao_id: 카카오톡 소셜 아이디
Returns:
{
token: JWT_TOKEN,
nickname: 닉네임
}, http status code
Exceptions:
InternalError: DATABASE가 존재하지 않을 때 발생
OperationalError: DATABASE 접속이 인가되지 않았을 때 발생
ProgramingError: SQL syntax가 잘못되었을 때 발생
IntegrityError: Key의 무결성을 해쳤을 때 발생
DataError: 컬럼 타입과 매칭되지 않는 값이 DB에 전달되었을 때 발생
"""
db = None
try:
access_token = request.headers['Authorization']
nickname = request.get_json(silent=True)
if not access_token:
return jsonify(message="TOKEN_DOES_NOT_EXIST"), 400
data = requests.get(
'https://kapi.kakao.com/v2/user/me',
headers={'Authorization': f'Bearer {access_token}'})
kakao_id = data.json()['id']
db = db_connector()
if db is None:
return jsonify(message="DATABASE_INIT_ERROR"), 500
kakao_user = model_dao.search_kakao_user(db, kakao_id)
# 가입된 계정인 경우 로그인 진행
if kakao_user:
nickname = kakao_user['nickname']
token = jwt.encode(kakao_user, SECRET_KEY, ALGORITHM)
return jsonify(token=token.decode('utf-8'),
nickname=nickname,
message="SIGN_IN_COMPLETE"), 200
# 가입되어있지 않은 계정인 경우 회원가입 진행
elif kakao_user is None:
# 닉네임 입력하지 않은 경우 에러처리
if nickname is None:
return jsonify(message="DATA_ERROR"), 400
db.begin()
social_id = model_dao.insert_kakao_user(db, kakao_id)
nickname = nickname['nickname']
kakao_user = model_dao.insert_kakao_into_user(
db, social_id, nickname)
token = jwt.encode({"id": kakao_user}, SECRET_KEY, ALGORITHM)
db.commit()
return jsonify(token=token.decode('utf-8'),
nickname=nickname,
message="SIGN_UP_COMPLETE"), 200
except pymysql.err.InternalError:
db.rollback()
return jsonify(message="DATABASE_DOES_NOT_EXIST"), 500
except pymysql.err.OperationalError:
db.rollback()
return jsonify(message="DATABASE_AUTHORIZATION_DENIED"), 500
except pymysql.err.ProgrammingError:
db.rollback()
return jsonify(message="DATABASE_SYNTAX_ERROR"), 500
except pymysql.err.IntegrityError:
db.rollback()
return jsonify(message="FOREIGN_KEY_CONSTRAINT_ERROR"), 500
except pymysql.err.DataError:
db.rollback()
return jsonify(message="DATA_ERROR"), 400
except Exception as e:
db.rollback()
return jsonify(message=f"{e}"), 500
finally:
if db:
db.close()
def membership_withdrawal(**kwargs):
"""회원 탈퇴 API
Headers:
token
Args:
None
Return:
None
Exceptions:
InternalError: DATABASE가 존재하지 않을 때 발생
OperationalError: DATABASE 접속이 인가되지 않았을 때 발생
ProgramingError: SQL syntax가 잘못되었을 때 발생
IntergrityError: Key의 무결성을 헤쳤을 때 발생
DataError: 컬럼 타입과 매칭되지 않는 값이 DB에 전달되었을 때 발생
KeyError: 엔드포인트에서 요구하는 키값이 전달되지 않았을 때 발생
"""
db = None
try:
user_id = kwargs['id']
db = db_connector()
if db is None:
return jsonify(message="DATABASE_INIT_ERROR"), 500
db.begin()
model_dao.delete_user(db, user_id)
model_dao.delete_user_diary(db, user_id)
model_dao.delete_user_series(db, user_id)
model_dao.delete_user_like(db, user_id)
db.commit()
return (''), 200
except pymysql.err.InternalError:
db.rollback()
return jsonify(message="DATABASE_DOES_NOT_EXIST"), 500
except pymysql.err.OperationalError:
db.rollback()
return jsonify(message="DATABASE_AUTHORIZATION_DENIED"), 500
except pymysql.err.ProgrammingError:
db.rollback()
return jsonify(message="DATABASE_SYNTAX_ERROR"), 500
except pymysql.err.IntegrityError:
db.rollback()
return jsonify(message="FOREIGN_KEY_CONSTRAINT_ERROR"), 500
except pymysql.err.DataError:
db.rollback()
return jsonify(message="DATA_ERROR"), 400
except KeyError:
db.rollback()
return jsonify(message="KEY_ERROR"), 400
except Exception as e:
db.rollback()
return jsonify(message=f"{e}"), 500
finally:
if db:
db.close
def google():
db = None
try:
data = request.json
GOOGLE_AUTH_URL = 'https://oauth2.googleapis.com/tokeninfo?id_token='
CORRECT_ISS_LIST = [
'accounts.google.com', 'https://accounts.google.com'
]
google_id = data['googleId']
google_token = data['token']
nickname = request.get_json(silent=True).get('nickname', None)
token_data = json.loads(
requests.get(GOOGLE_AUTH_URL + google_token).text)
if (token_data['iss']
not in CORRECT_ISS_LIST) or (token_data['sub'] != google_id):
return {'message': 'MODIFIED_TOKEN'}, 401
db = db_connector()
if db is None:
return jsonify(message="DATABASE_INIT_ERROR"), 500
google_user = model_dao.serch_google_user(db, google_id)
# 가입된 계정인 경우 로그인 진행
if google_user:
token = jwt.encode(google_user, SECRET_KEY, ALGORITHM)
return jsonify(token=token.decode('utf-8'), nickname=nickname), 200
elif google_user is None:
db.begin()
social_id = model_dao.insert_google_user(db, google_id)
if nickname:
google_user = model_dao.insert_google_into_user(
db, social_id, nickname)
token = jwt.encode(google_user, SECRET_KEY, ALGORITHM)
return jsonify(token=token.decode('utf-8'),
nickname=nickname), 200
elif nickname is None:
return jsonify(message="DATA_ERROR"), 400
db.commit()
except pymysql.err.InternalError:
return jsonify(message="DATABASE_DOES_NOT_EXIST"), 500
except pymysql.err.OperationalError:
return jsonify(message="DATABASE_AUTHORIZATION_DENIED"), 500
except pymysql.err.ProgrammingError:
return jsonify(message="DATABASE_SYNTAX_ERROR"), 500
except pymysql.err.IntegrityError:
return jsonify(message="FOREIGN_KEY_CONSTRAINT_ERROR"), 500
except pymysql.err.DataError:
return jsonify(message="DATA_ERROR"), 400
except Exception as e:
return jsonify(message=f"{e}"), 500
finally:
if db:
db.close()
def change_public(**kwargs):
"""다이어리 공개 여부 변경 API.
Headers:
token
Args:
user_id:
diary_id: 다이어리 id
status: 공개 여부
Return:
None
Exceptions:
InternalError: DATABASE가 존재하지 않을 때 발생
OperationalError: DATABASE 접속이 인가되지 않았을 때 발생
ProgramingError: SQL syntax가 잘못되었을 때 발생
IntegrityError: Key의 무결성을 해쳤을 때 발생
DataError: 컬럼 타입과 매칭되지 않는 값이 DB에 전달되었을 때 발생
KeyError: 엔드포인트에서 요구하는 키값이 전달되지 않았을 때 발생
"""
db = None
try:
user_id = kwargs['id']
diaries = request.json['diary_id']
# Public 상태 변경
status = request.args['status']
if status == 'public':
public = 1
elif status == 'secret':
public = 0
# requset body로 들어온 diary id를 tuple로 변경
diary_list = []
for diary in diaries:
diary_id = diary['id']
diary_list.append(diary_id)
diary_tuple = tuple(diary_list)
db = db_connector()
if db is None:
return jsonify(message="DATABASE_INIT_ERROR"), 500
db.begin()
model_dao.change_diary_public(db, public, diary_tuple, user_id)
db.commit()
return (''), 200
except pymysql.err.InternalError:
db.rollback()
return jsonify(message="DATABASE_DOES_NOT_EXIST"), 500
except pymysql.err.OperationalError:
db.rollback()
return jsonify(message="DATABASE_AUTHORIZATION_DENIED"), 500
except pymysql.err.ProgrammingError:
db.rollback()
return jsonify(message="DATABASE_SYNTAX_ERROR"), 500
except pymysql.err.IntegrityError:
db.rollback()
return jsonify(message="FOREIGN_KEY_CONSTRAINT_ERROR"), 500
except pymysql.err.DataError:
db.rollback()
return jsonify(message="DATA_ERROR"), 400
except KeyError:
db.rollback()
return jsonify(message="KEY_ERROR"), 400
except Exception as e:
db.rollback()
return jsonify(message=f"{e}"), 500
finally:
if db:
db.close()
import os, sys
import pymysql
ROOT_DIR = os.path.dirname(os.path.abspath("API"))
BASE_DIR = os.path.dirname(os.path.abspath(__file__))
sys.path.extend([ROOT_DIR])
os.chdir(BASE_DIR)
from database_utils import init_databases, import_aquery
from connections import db_connector
db = db_connector()
cursor = db.cursor()
db.begin()
init_databases(db)
with open('whisper_20200708_14_12.txt', 'r') as f:
TABLE_QUERIES = import_aquery(f)
for query in TABLE_QUERIES:
cursor.execute(query)
db.commit()
cursor.close()
db.close()
print('COMPLETE')
