def delete_blog(blog_id, user_id):
"""
:param blog_id:
:param user_id:
:return:
code: '-1: error, 0: success, 3: blog is not existed'
"""
conn = None
cursor = None
code = -1
try:
conn = db.get_connection()
if conn.is_connected():
cursor = conn.cursor()
sql = "Select id from blogs where id = %s and user_id = %s " % (
blog_id, user_id)
logger.info(sql)
cursor.execute(sql)
rows = cursor.fetchall()
if len(rows) > 0:
sql = "Delete from blogs where id = %s and user_id = %s" % (
blog_id, user_id)
logger.info(sql)
cursor.execute(sql)
conn.commit()
code = 0
else:
code = 3
except Exception as e:
log_exception(e)
finally:
close_cursor_connection(cursor)
close_db_connection(conn)
return code
def like_blog(blog_id, user_id):
"""
:param blog_id:
:param user_id:
:return:
code: '-1: error, 0: success, 3: blog is not existed'
"""
conn = None
cursor = None
code = -1
try:
conn = db.get_connection()
if conn.is_connected():
cursor = conn.cursor()
sql = "Select id from blogs where id = %s" % blog_id
logger.info(sql)
cursor.execute(sql)
rows = cursor.fetchall()
if len(rows) > 0:
sql = "Insert into like_blog (blog_id, user_id) values (%s,%s) " \
"on duplicate key update created_time = now()" \
% (blog_id, user_id)
logger.info(sql)
cursor.execute(sql)
conn.commit()
code = 0
else:
code = 3
except Exception as e:
log_exception(e)
finally:
close_cursor_connection(cursor)
close_db_connection(conn)
return code
def create_blog(user_id, title, content):
"""
:param user_id:
:param title:
:param content:
:return:
code: '-1: error, 0: success'
"""
conn = None
cursor = None
code = -1
try:
conn = db.get_connection()
if conn.is_connected():
cursor = conn.cursor()
sql = "Insert into blogs (user_id,title,content) values (%s,'%s','%s')" % (
user_id, title, content)
logger.info(sql)
cursor.execute(sql)
conn.commit()
code = 0
except Exception as e:
log_exception(e)
finally:
close_cursor_connection(cursor)
close_db_connection(conn)
return code
def check_user_active(user_id):
"""
:param user_id:
:return:
code: '-1: error, 0: success, 1: user is not existed, 2: user not active'
"""
conn = None
cursor = None
code = -1
try:
conn = db.get_connection()
if conn.is_connected():
cursor = conn.cursor(dictionary=True)
sql = "Select id, status from users " \
"where id = '%s' order by id desc limit 0,1" \
% user_id
logger.info(sql)
cursor.execute(sql)
rows = cursor.fetchall()
if len(rows) > 0:
for row in rows:
if row['status'] == 0:
code = 2
if row['status'] == 1:
code = 0
else:
"""User is not existed"""
code = 1
except Exception as e:
log_exception(e)
finally:
close_cursor_connection(cursor)
close_db_connection(conn)
return code
def update_user_info(email, login_type, full_name, mobile_number, occupation):
"""
:param email:
:param login_type:
:param full_name:
:param mobile_number:
:param occupation:
:return:
code: '-1: error, 0: success, 1: user is not existed, 2: wrong logic'
"""
conn = None
cursor = None
code = -1
try:
conn = db.get_connection()
if conn.is_connected():
cursor = conn.cursor(dictionary=True)
sql = "Select google_id, facebook_id from users " \
"where email = '%s' order by id desc limit 0,1" \
% email
logger.info(sql)
cursor.execute(sql)
rows = cursor.fetchall()
if len(rows) > 0:
for row in rows:
google_id = row['google_id']
facebook_id = row['facebook_id']
if login_type == 1:
"""Login via Google"""
if google_id is None:
code = 2
else:
sql = "Update users set full_name = '%s', occupation = '%s', status = 1 " \
"where email = '%s'" % (full_name, occupation, email)
logger.info(sql)
cursor.execute(sql)
conn.commit()
code = 0
if login_type == 2:
"""Login via Facebook"""
if facebook_id is None:
code = 2
else:
sql = "Update users set full_name = '%s', mobile_number = '%s', status = 1 " \
"where email = '%s'" % (full_name, mobile_number, email)
logger.info(sql)
cursor.execute(sql)
conn.commit()
code = 0
else:
"""User is not existed"""
code = 1
except Exception as e:
log_exception(e)
finally:
close_cursor_connection(cursor)
close_db_connection(conn)
return code
def get_user_info():
"""
Get User Info
---
tags:
- User
parameters:
- in: query
name: email
type: string
required: true
description: Email
responses:
200:
description: Ok
schema:
properties:
code:
type: integer
required: true
description: '-1: error, 0: success, 1: user is not existed'
info:
type: object
required: true
properties:
id:
type: integer
email:
type: string
full_name:
type: string
mobile_number:
type: string
occupation:
type: string
400:
description: Bad Request
500:
description: Internal Server Error
"""
try:
"""Validate parameters"""
email = request.args.get('email')
if email is None:
abort(400)
info = {
'email': email,
}
validate, error_detail = schema.validate_api_get_user_info(info)
if validate:
code, info = db.get_user_info(email)
return jsonify({'code': code, 'info': info}), 200
else:
return jsonify(error_detail), 400
except Exception as e:
log_exception(e)
abort(500)
def list_blogs_by_user(user_id, page, size):
"""
:param user_id:
:param page:
:param size:
:return:
code: '-1: error, 0: success'
info = [
{
'id': id,
'title' : title,
'content': content,
}
]
"""
conn = None
cursor = None
code = -1
list_blogs = []
try:
conn = db.get_connection()
if conn.is_connected():
cursor = conn.cursor(dictionary=True)
offset = (page - 1) * size
sql = "Select id, title, content from blogs " \
"where user_id = %s order by updated_time, created_time desc limit %s,%s" % (user_id, offset, size)
logger.info(sql)
cursor.execute(sql)
rows = cursor.fetchall()
if len(rows) > 0:
for row in rows:
info = {
'id': row['id'],
'title': row['title'],
'content': row['content'],
}
list_blogs.append(info)
code = 0
except Exception as e:
log_exception(e)
finally:
close_cursor_connection(cursor)
close_db_connection(conn)
return code, list_blogs
def get_user_info(email):
"""
:param email:
:return:
code: '-1: error, 0: success, 1: user is not existed'
info: {
'email':email,
'full_name': full_name,
'mobile_number': mobile_number,
'occupation': mobile_number,
}
"""
conn = None
cursor = None
code = -1
info = {}
try:
conn = db.get_connection()
if conn.is_connected():
cursor = conn.cursor(dictionary=True)
sql = "Select id, email, full_name, mobile_number,occupation from users " \
"where email = '%s' order by id desc limit 0,1" \
% email
logger.info(sql)
cursor.execute(sql)
rows = cursor.fetchall()
if len(rows) > 0:
for row in rows:
info['id'] = row['id']
info['email'] = row['email']
info['full_name'] = row['full_name']
info['mobile_number'] = row['mobile_number']
info['occupation'] = row['occupation']
code = 0
else:
"""User is not existed"""
code = 1
except Exception as e:
log_exception(e)
finally:
close_cursor_connection(cursor)
close_db_connection(conn)
return code, info
def list_user_like_blog(blog_id):
"""
:param blog_id:
:return:
code: '-1: error, 0: success'
info = [
{
'id': id,
'full_name' : title,
}
]
"""
conn = None
cursor = None
code = -1
list_users = []
try:
conn = db.get_connection()
if conn.is_connected():
cursor = conn.cursor(dictionary=True)
sql = "Select a.id, a.full_name from users a, like_blog b where a.id = b.user_id and b.blog_id = %s " \
"order by b.created_time desc" % blog_id
logger.info(sql)
cursor.execute(sql)
rows = cursor.fetchall()
if len(rows) > 0:
for row in rows:
info = {
'id': row['id'],
'full_name': row['full_name'],
}
list_users.append(info)
code = 0
except Exception as e:
log_exception(e)
finally:
close_cursor_connection(cursor)
close_db_connection(conn)
return code, list_users
def get_blog_detail(blog_id):
"""
:param blog_id:
:return:
code: '-1: error, 0: success, 3: blog is not existed'
info = {
'id': id,
'title' : title,
'content': content,
}
"""
conn = None
cursor = None
code = -1
info = {}
try:
conn = db.get_connection()
if conn.is_connected():
cursor = conn.cursor(dictionary=True)
sql = "Select id, title, content from blogs where id = %s" % blog_id
logger.info(sql)
cursor.execute(sql)
rows = cursor.fetchall()
if len(rows) > 0:
for row in rows:
info['id'] = row['id']
info['title'] = row['title']
info['content'] = row['content']
code = 0
else:
code = 3
except Exception as e:
log_exception(e)
finally:
close_cursor_connection(cursor)
close_db_connection(conn)
return code, info
def update_blog(blog_id, user_id, title, content):
"""
:param blog_id:
:param user_id:
:param title:
:param content:
:return:
code: '-1: error, 0: success, 3: blog is not existed'
"""
conn = None
cursor = None
code = -1
try:
conn = db.get_connection()
if conn.is_connected():
cursor = conn.cursor()
sql = "Select id from blogs where id = %s and user_id = %s " % (
blog_id, user_id)
logger.info(sql)
cursor.execute(sql)
rows = cursor.fetchall()
if len(rows) > 0:
sql = "Update blogs set title = '%s', content = '%s', udpated_time = now() " \
"where id = %s and user_id = %s" % (title, content, blog_id, user_id)
logger.info(sql)
cursor.execute(sql)
conn.commit()
code = 0
else:
code = 3
except Exception as e:
log_exception(e)
finally:
close_cursor_connection(cursor)
close_db_connection(conn)
return code
def like_blog():
"""
Like
---
tags:
- Blog
parameters:
- in: query
name: blog_id
type: integer
required: true
description: Blog ID
- in: query
name: user_id
type: integer
required: true
description: User ID
responses:
200:
description: Ok
schema:
properties:
code:
type: integer
required: true
description: '-1: error, 0: success, 1: user is not existed,
2: user not active'
400:
description: Bad Request
500:
description: Internal Server Error
"""
try:
"""Validate parameters"""
user_id = request.args.get('user_id')
if user_id is None:
abort(400)
try:
user_id = int(user_id)
except:
pass
blog_id = request.args.get('blog_id')
if blog_id is None:
abort(400)
try:
blog_id = int(blog_id)
except:
pass
info = {
'blog_id': blog_id,
'user_id': user_id,
}
validate, error_detail = schema.validate_api_like_blog(info)
if validate:
code = db.check_user_active(user_id)
if code == 0:
code = db.like_blog(blog_id, user_id)
return jsonify({'code': code}), 200
else:
return jsonify(error_detail), 400
except Exception as e:
log_exception(e)
abort(500)
def list_blog_by_user():
"""
List Blog by User
---
tags:
- Blog
parameters:
- in: query
name: user_id
type: integer
required: true
description: User ID Login
- in: query
name: page
type: integer
required: true
description: Page
- in: query
name: size
type: integer
required: true
description: Size
responses:
200:
description: Ok
schema:
properties:
code:
type: integer
required: true
description: '-1: error, 0: success, 1: user is not existed,
2: user not active'
info:
type: array
required: true
400:
description: Bad Request
500:
description: Internal Server Error
"""
try:
"""Validate parameters"""
user_id = request.args.get('user_id')
if user_id is None:
abort(400)
try:
user_id = int(user_id)
except:
pass
page = request.args.get('page')
if page is None:
abort(400)
try:
page = int(page)
except:
pass
size = request.args.get('size')
if size is None:
abort(400)
try:
size = int(size)
except:
pass
info = {
'user_id': user_id,
'page': page,
'size': size,
}
validate, error_detail = schema.validate_api_list_blog(info)
if validate:
code = db.check_user_active(user_id)
if code == 0:
code, lists = db.list_blogs_by_user(user_id, page, size)
return jsonify({'code': code, 'info': lists}), 200
else:
return jsonify({'code': code}), 200
else:
return jsonify(error_detail), 400
except Exception as e:
log_exception(e)
abort(500)
def create_blog():
"""
Create blog
---
tags:
- Blog
parameters:
- in: body
name: blog
required: true
description: Blog info
schema:
id: blog
required:
- user_id
- title
- content
properties:
user_id:
type: integer
required: true
description: User ID
title:
type: string
required: true
description: Title
content:
type: string
required: true
description: Content
responses:
200:
description: Ok
schema:
properties:
code:
type: integer
required: true
description: '-1: error, 0: success, 1: user is not existed,
2: user not active'
400:
description: Bad Request
500:
description: Internal Server Error
"""
try:
"""Validate parameters"""
if request.headers['Content-Type'] == 'application/json':
body = request.json
validate, error_detail = schema.validate_api_create_blog(body)
if validate:
code = db.check_user_active(body['user_id'])
if code == 0:
code = db.create_blog(body['user_id'], body['title'],
body['content'])
return jsonify({'code': code}), 200
else:
return jsonify(error_detail), 400
else:
abort(415)
except Exception as e:
log_exception(e)
abort(500)
def update_user_info():
"""
Update User Info
---
tags:
- User
parameters:
- in: query
name: email
type: string
required: true
description: Email
- in: query
name: login_type
type: integer
required: true
description: '1: login via Google, 2: login via Facebook'
- in: query
name: full_name
type: string
required: true
description: Full Name
- in: query
name: mobile_number
type: string
required: false
description: Mobile Number
- in: query
name: occupation
type: string
required: false
description: Occupation
responses:
200:
description: Ok
schema:
properties:
code:
type: integer
required: true
description: '-1: error, 0: success, 1: user is not existed, 2: wrong logic'
400:
description: Bad Request
500:
description: Internal Server Error
"""
try:
"""Validate parameters"""
email = request.args.get('email')
if email is None:
abort(400)
login_type = request.args.get('login_type')
if login_type is None:
abort(400)
try:
login_type = int(login_type)
except:
pass
full_name = request.args.get('full_name')
if full_name is None:
abort(400)
mobile_number = request.args.get('mobile_number')
try:
mobile_number = long(mobile_number)
except:
pass
occupation = request.args.get('occupation')
info = {
'email': email,
'login_type': login_type,
'full_name': full_name,
'mobile_number': mobile_number,
'occupation': occupation,
}
validate, error_detail = schema.validate_api_update_user_info(
info, login_type)
if validate:
code = db.update_user_info(email, login_type, full_name,
mobile_number, occupation)
return jsonify({'code': code}), 200
else:
return jsonify(error_detail), 400
except Exception as e:
log_exception(e)
abort(500)
def login(email, sso_id, login_type):
"""
:param email:
:param sso_id:
:param login_type:
:return:
code: '-1: error, 0: success, 1: need more info for login via Google,
2: need more info for login via Facebook, 3: wrong logic'
"""
conn = None
cursor = None
code = -1
try:
conn = db.get_connection()
if conn.is_connected():
cursor = conn.cursor(dictionary=True)
sql = "Select full_name, mobile_number, occupation, facebook_id, google_id from users " \
"where email = '%s' order by id desc limit 0,1" \
% email
logger.info(sql)
cursor.execute(sql)
rows = cursor.fetchall()
if len(rows) > 0:
"""User existed"""
for row in rows:
full_name = row['full_name']
mobile_number = row['mobile_number']
occupation = row['occupation']
facebook_id = row['facebook_id']
google_id = row['google_id']
if login_type == 1:
"""Login via Google"""
if google_id is not None and sso_id == google_id:
if full_name is not None and occupation is not None:
"""Full Name and Occupation are enough"""
code = 0
else:
code = 1
else:
code = 3
if login_type == 2:
"""Login via Facebook"""
if facebook_id is not None and sso_id == facebook_id:
if full_name is not None and mobile_number is not None:
"""Full Name and Mobile Number are enough"""
code = 0
else:
code = 2
else:
code = 3
else:
"""User is not existed"""
"""Login via Google"""
code = 1
sql = "Insert into users (email,google_id,login_time) values ('%s','%s', now())" % (
email, sso_id)
if login_type == 2:
"""Login via Facebook"""
code = 2
sql = "Insert into users (email,facebook_id,login_time) values ('%s','%s', now())" % (
email, sso_id)
logger.info(sql)
cursor.execute(sql)
conn.commit()
except Exception as e:
log_exception(e)
finally:
close_cursor_connection(cursor)
close_db_connection(conn)
return code
def login():
"""
Login
---
tags:
- User
parameters:
- in: query
name: email
type: string
required: true
description: Email
- in: query
name: sso_id
type: string
required: true
description: Google ID or Facebook ID
- in: query
name: login_type
type: integer
required: true
description: '1: login via Google, 2: login via Facebook'
responses:
200:
description: Ok
schema:
properties:
code:
type: integer
required: true
description: '-1: error, 0: success, 1: need more info for login via Google,
2: need more info for login via Facebook, 3: wrong logic'
400:
description: Bad Request
500:
description: Internal Server Error
"""
try:
"""Validate parameters"""
email = request.args.get('email')
if email is None:
abort(400)
sso_id = request.args.get('sso_id')
if sso_id is None:
abort(400)
login_type = request.args.get('login_type')
if login_type is None:
abort(400)
try:
login_type = int(login_type)
except:
pass
info = {'email': email, 'sso_id': sso_id, 'login_type': login_type}
validate, error_detail = schema.validate_api_login(info)
if validate:
code = db.login(email, sso_id, login_type)
return jsonify({'code': code}), 200
else:
return jsonify(error_detail), 400
except Exception as e:
log_exception(e)
abort(500)