def init_db():
try:
engine = create_engine(configObject.DATABASE_URI,
convert_unicode=True,
echo=False)
Session.configure(bind=engine)
Base.query = Session.query_property()
except Exception as e:
print("Database Connection Error")
print(e)
def get_post_detail(post_id):
"""
query post details including likes and comments
:param post_id:
:return:
"""
db_session = Session()
post_info = db_session.query(Post, User, func.count(distinct(
Like.like_id))).filter(Post.post_id == post_id).join(
User, User.user_id == Post.user_id).outerjoin(
Like,
and_(Like.post_id == post_id,
Like.user_id == session['user_id'],
Like.is_unliked == False)).one_or_none()
if post_info is None:
return PostMessage.POST_NOT_FOUND
comments = db_session.query(
Comment, User.username).filter(Comment.post_id == post_id).join(
User, User.user_id == Comment.user_id).all()
likes = db_session.query(User.username).join(
Like, Like.user_id == User.user_id).filter(
and_(Like.post_id == post_id, Like.is_unliked == False)).all()
post = post_info[0]
user = post_info[1]
like = post_info[2]
return {
'id':
post.post_id,
'title':
post.post_title,
'body':
post.post_body,
'img_url':
post.post_img_url,
'liked':
True if like else False,
'likes':
likes,
'comments': [{
'comment_body': comment.comment_body,
'username': username
} for comment, username in comments],
'user': {
'user_id': user.user_id,
'username': user.username
}
}
def get_follow_timeline():
"""
query all posts of follows
:return:
"""
db_session = Session()
user_ids = [
follow.follow_user_id
for follow in db_session.query(Follow.follow_user_id).filter(
and_(Follow.user_id == session['user_id'], Follow.is_unfollowed ==
False))
]
user_ids.append(session['user_id'])
return get_timeline(db_session, user_ids)
def verify_token_url(email, token):
"""
verify a token and updates appropriate table
:param email: email of user
:param token: token
:return: appropriate success/fail message of class TokenMessage
"""
db_session = Session()
db_obj = db_session.query(User, Token).filter(
User.email == email, User.user_status == UserStatus.temporary).filter(
Token.user_id == User.user_id,
Token.token_status == TokenStatus.pending,
Token.token_type == TokenType.email_verify).one_or_none()
if db_obj is None:
return TokenMessage.TOKEN_NOT_FOUND
user_obj = db_obj[0]
token_obj = db_obj[1]
# token/user exists?
if token_obj is None or user_obj is None:
return TokenMessage.TOKEN_NOT_FOUND
# token expired?
if (datetime.now() - timedelta(hours=24)) > token_obj.created_at:
return TokenMessage.TOKEN_EXPIRED
# token correct?
if token_obj.verify_token(token) is False:
return TokenMessage.TOKEN_INCORRECT
# update token status and user status
token_obj.token_status = TokenStatus.verified
user_obj.user_status = UserStatus.active
db_session.commit()
db_session.close()
return TokenMessage.VERIFY_SUCCESS
def login_api(login_form):
"""
api that logs a user in. if successful, adds user info to flask session
:param login_form: WTForm login filled in
:return: an appropriate success/failure message from message.py
"""
db_session = Session()
matched_user = db_session.query(User).filter(
User.email == login_form.email.data,
User.user_status == UserStatus.active).one_or_none()
if matched_user is None:
return UserMessage.EMAIL_PASSWORD_NOT_MATCH
if matched_user.authenticate_password(login_form.password.data) is False:
return UserMessage.EMAIL_PASSWORD_NOT_MATCH
session['logged_in'] = True
session['user_id'] = matched_user.user_id
session['username'] = matched_user.username
session['profile_img'] = matched_user.profile_img_url
return UserMessage.LOGIN_SUCCESS
def get_my_posts(username):
"""
query all posts by user with username
:return: list of dicts of posts, follow_info
"""
db_session = Session()
user_info = get_follow_info_by_username(db_session, username)
if not user_info:
return [], None
return get_timeline(db_session, [user_info['user_id']]), user_info
def follow_user():
other_user = request.form['username']
db_session = Session()
unfollowed = False
existing_follow = db_session.query(Follow).filter(
and_(Follow.user_id == session['user_id'],
Follow.follow_user_id == User.user_id)).join(
User, User.username == other_user).one_or_none()
if existing_follow:
unfollowed = not existing_follow.is_unfollowed
existing_follow.is_unfollowed = unfollowed
else:
new_follow = Follow(
session['user_id'],
db_session.query(User.user_id).filter(User.username == other_user))
db_session.add(new_follow)
db_session.commit()
return jsonify({'status': 0, 'unfollowed': unfollowed})
def create_post_api(post_form):
"""
add post to db
:param post_form:
:return:
"""
db_session = Session()
new_post = Post(session['user_id'])
post_form.populate_obj(new_post)
db_session.add(new_post)
db_session.commit()
return True
def account_page():
db_session = Session()
user_obj = get_current_user_obj(db_session)
account_form = UserAccountForm(request.form, obj=user_obj)
if request.method == 'POST':
if account_form.validate():
account_form.populate_obj(user_obj)
db_session.commit()
session['username'] = account_form.username.data
session['profile_img'] = account_form.profile_img_url.data
db_session.close()
return render_template('user/account.html',
title="Account",
description="Account Detail",
nav=logged_in_nav(),
user=logged_in_user(),
form=account_form)
def like_post_api(post_id):
"""
like post (add on db)
:param post_id:
:return: False if error occurs
"""
db_session = Session()
try:
existing_like = db_session.query(Like).filter(
and_(Like.post_id == post_id,
Like.user_id == session['user_id'])).one_or_none()
if existing_like:
existing_like.is_unliked = not existing_like.is_unliked
else:
db_session.add(Like(post_id, session['user_id']))
db_session.commit()
except Exception as e:
print(e)
return False
return True
def comment_post_api(post_id, comment):
"""
comment on a post (add on db)
:param post_id:
:param comment:
:return: False if error occurs
"""
if not comment:
return False
db_session = Session()
try:
db_session.add(Comment(post_id, session['user_id'], comment))
db_session.commit()
except Exception as e:
print(e)
return False
return True
def signup_api(signup_form):
"""
api that registers new users
:param signup_form: WTForm filled form
:return: an appropriate success or failure message from message.py
"""
db_session = Session()
if db_session.query(User).filter(
User.email == signup_form.email.data,
User.user_status != UserStatus.deleted).one_or_none() is not None:
# if email is used, return error
return signup_form.email.data + UserMessage.USER_EXISTS
# insert into db
new_user = User(signup_form.email.data, signup_form.password.data)
new_username = new_user.set_unique_username(db_session)
db_session.add(new_user)
db_session.flush()
# email verification token
verif_token = new_user.generate_verif_token("email_verification")
new_token = Token(verif_token, TokenType.email_verify, new_user.user_id)
db_session.add(new_token)
# email user
if send_user_verif_email(new_username, signup_form.email.data,
verif_token) == UserMessage.EMAIL_ERROR:
return UserMessage.EMAIL_ERROR
db_session.commit()
db_session.close()
return UserMessage.SIGNUP_SUCCESS