def get_user_search_info(owner_email, user_nickname):
try:
user = session.query(User).filter(
User.nickname.like(f"{user_nickname}%")).all()
except SQLAlchemyError:
session.rollback()
return abort(418, "db_error")
return {
"users": [{
"email":
user_info.email,
"img":
user_info.img,
"nickname":
user_info.nickname,
"listening":
session.query(Listen).filter(
Listen.listeningEmail == user_info.email).count(),
"listener":
session.query(Listen).filter(
Listen.listenerEmail == user_info.email).count(),
"isListening":
True if session.query(Listen).filter(
Listen.listenerEmail == owner_email).filter(
Listen.listeningEmail == user_info.email).first() else
False
} for user_info in user]
}
def listening(owner_email, listening_email):
if owner_email == listening_email:
return abort(400, "can't listen yourself")
listening_state = session.query(Listen).\
filter(Listen.listeningEmail == listening_email).\
filter(Listen.listenerEmail == owner_email).first()
if listening_state:
return abort(400, "already listening")
listening_user = session.query(User).filter(
User.email == listening_email).first()
if listening_user:
try:
new_listening = Listen(listeningEmail=listening_email,
listenerEmail=owner_email)
session.add(new_listening)
session.commit()
return {"message": "Success"}
except SQLAlchemyError:
session.rollback()
return abort(418, "db_error")
else:
return abort(404, "No such user")
def get_post_detail(post_id):
post_detail = session.query(Posts).filter(Posts.id == post_id).first()
if post_detail:
return {
"title": post_detail.title,
"content": post_detail.content,
"created_at": str(post_detail.created_at)
}
else:
return abort(404, 'There is no post you looking for')
def delete_post(post_id):
del_data = session.query(Posts).filter(Posts.id == post_id).first()
if del_data:
session.delete(del_data)
session.commit()
return {'message': 'Delete post successfully'}
else:
return abort(404, 'There is no post you looking for')
def update_post(post_id, title, content):
udt_post = session.query(Posts).filter(Posts.id == post_id).first()
if udt_post:
udt_post.title = title
udt_post.content = content
session.commit()
return {'message': 'Update post successfully'}
else:
return abort(404, 'There is no post you looking for')
def logout(email):
user = session.query(User).filter(User.email == email).first()
if user:
user.refresh_token = None
session.commit()
return {"message": "logout successfully"}
else:
return abort(401, "cannot find token user")
def get_posts():
posts = session.query(Posts).all()
if posts:
return {
"posts": [{
"title": post.title,
"content": post.content,
"created_at": str(post.created_at)
} for post in posts]
}
else:
return abort(404, 'There is not any post')
def withdrawal(email):
del_user = session.query(User).filter(User.email == email).first()
if del_user:
token = Redis.get(email)
if token:
Redis.delete(email)
session.delete(del_user)
session.commit()
return {"message": "success"}, 204
else:
abort(401, 'could not find user')
def get_profile_timeline(user_email, profile_user_email, page):
limit = 7
try:
user = session.query(User).filter(User.email == profile_user_email).first()
except SQLAlchemyError:
session.rollback()
return abort(418, "db_error")
page = (page - 1) * limit
if user is None:
return abort(404, "User not Found")
try:
posts = session.query(Post) \
.filter(Post.userEmail == profile_user_email) \
.order_by(Post.createdAt.desc()) \
.all()[page:page + limit]
except SQLAlchemyError:
session.rollback()
return abort(418, "db_error")
return {
"posts": [{
"id": post.id,
"user": {
"email": user.email,
"nickname": user.nickname,
"img": user.img
},
"content": post.content,
"sound": post.sound,
"img": post.img,
"yally": session.query(Yally).filter(Yally.postId == post.id).count(),
"comment": session.query(Comment).filter(Comment.postId == post.id).count(),
"isYally": True if session.query(Yally).filter(Yally.userEmail == user_email).filter(Yally.postId == post.id).first() else False,
"createdAt": str(post.createdAt)
}for post in posts]
}
def get_notice_list(off_set, limit_num):
notice_list = session.query(Notice, User)\
.filter(Notice.user_email == User.email)\
.order_by(Notice.created_at.desc())\
.offset(off_set).limit(limit_num)
next_notice = session.query(Notice).offset(off_set + limit_num).first()
next_page = False
if next_notice:
next_page = True
return {
"notice": [{
"id": n.id,
"title": n.title,
"content": n.content,
"user_name": u.name,
"created_at": str(n.created_at)
} for n, u in notice_list],
"next_page":
next_page
}, 200
def send_email(email, codetype):
user = session.query(User).filter(User.email == email).first()
if codetype == 'auth':
if user:
return abort(409, "This email is already sign up")
return send_auth_code_email(email)
elif codetype == 'reset':
if user:
return send_reset_code_email(email)
return abort(404, "User not found")
def delete_notice(notice_id, user_email):
del_notice = session.query(Notice).filter(Notice.id == notice_id).first()
if del_notice:
if del_notice.user_email == user_email:
session.delete(del_notice)
session.commit()
return {"message": "success"}, 204
else:
abort(403, 'could not delete notice created by others')
else:
abort(404, 'could not find notice matching this id')
def send_email_code(email):
user = session.query(User).filter(User.email == email).first()
if user:
abort(409, 'this email is already in use')
code = f"{random.randint(111111, 999999):04d}"
title = "GRAMO 이메일 인증 메일"
content = f"이메일 인증 코드는 {code}입니다."
send_email(title=title, content=content, adress=email)
Redis.setex(name=email, value=code, time=180)
return {"message": "success"}, 200
def change_password(email, code, password):
if check_reset_code(email, code):
user = session.query(User).filter(User.email == email).first()
if user:
user.password = generate_password_hash(password)
session.commit()
return {"message": "Successfully password changed"}
else:
return abort(404, "The email is incorrect")
else:
return abort(401, "The verification code is not correct")
def sign_up(email, password, name, major):
origin_user = session.query(User).filter(User.email == email).first()
if origin_user:
abort(409, "this email is already in use")
else:
add_user = User(email=email,
password=generate_password_hash(password),
name=name,
major=major,
email_status=1)
session.add(add_user)
session.commit()
return {"message": "success"}, 201
def sign_up(email, password, name, phone_number, gender):
user = session.query(User).filter(User.email == email).first()
if user:
return abort(409, 'This email already signed up')
add_user = User(email=email,
password=generate_password_hash(password),
name=name,
phone_number=phone_number,
gender=gender)
session.add(add_user)
session.commit()
return {'message': 'Sign up successfully'}, 201
def get_detail_notice(notice_id):
notice = session.query(Notice, User).\
filter(Notice.user_email == User.email).\
filter(Notice.id == notice_id).all()
if notice:
return {
"notice": {
"name": notice[0][1].name,
"created_at": str(notice[0][0].created_at),
"title": notice[0][0].title,
"content": notice[0][0].content
}
}, 200
else:
abort(404, 'could not find notice matching this id')
def login(email, password):
user = session.query(User).filter(User.email == email).first()
check_user_pw = check_password_hash(user.passward,
password) if user else None
if check_user_pw:
access_token = create_access_token(identity=email)
refresh_token = create_refresh_token(identity=email)
user.refresh_token = refresh_token
session.commit()
return {"access_token": access_token, "refresh_token": refresh_token}
else:
return abort(400, "The email or password is incorrect")
def sign_up(email, password, nickname, age):
user = session.query(User).filter(User.email == email).first()
if user:
return abort(409, "This email is already sign up")
try:
create_new_user(email, password, nickname, age)
return {
"message": "Successfully signed up"
}, 201
except SQLAlchemyError:
session.rollback()
return abort(418, "db_error")
def login(email, password):
user = session.query(User).filter(User.email == email).first()
if user:
user_pw = check_password_hash(user.password, password)
if user_pw:
access_token = create_access_token(identity=email)
refresh_token = create_refresh_token(identity=email)
return {
"accessToken": access_token,
"refreshToken": refresh_token
}
else:
return abort(400, "The password is incorrect")
else:
return abort(404, "The email is incorrect")
def login(email, password):
user = session.query(User).filter(User.email == email).first()
if user:
check_user_pw = check_password_hash(user.password, password)
if check_user_pw:
access_token = create_access_token(identity=email)
refresh_token = create_refresh_token(identity=email)
Redis.setex(name=email, value=refresh_token, time=604800)
return {
"name": user.name,
"major": user.major,
"access_token": access_token,
"refresh_token": refresh_token
}, 201
else:
abort(404, 'email and password does not match')
else:
abort(404, 'email and password does not match')