def update_profile(id):
request_data = request.get_json()
if not request_data:
return bad_request("No input data provided")
try:
data = ProfileSchema().load(request_data)
except ValidationError as error:
return error_response(422, error.messages)
try:
user = User.find_by_id(id)
profile = Profile.find_by_id(user.profile.id)
profile.firstname = data.get('firstname').title()
profile.lastname = data.get('lastname').title()
profile.bio = data.get('bio')
prof = Profile.find_by_username(data.get('username'))
if prof is not None:
if prof.user_id != id:
return bad_request('Username is already taken.')
profile.username = data.get('username')
profile.save()
response = jsonify({'message': 'Successfully updated your profile'})
response.status_code = 200
return response
except Exception:
return error_response(500, 'Something went wrong, please try again.')
def check_username():
data = request.get_json()
user = Profile.find_by_username(data.get('username'))
if user is not None:
if user.id != id:
return {'res': False}
return {'res': True}
def check_username(id):
data = request.get_json()
profile = Profile.find_by_username(data.get('username'))
if profile is not None:
if profile.user_id != id:
return {'res': False}
return {'res': True}
def add_user(
name,
email,
username='',
avatar='',
bio='',
is_admin=False,
):
profile = Profile(name=name, bio=bio, username=username)
profile.avatar = avatar or profile.set_avatar(email)
user = User(password='******')
user.email = email
user.is_admin = is_admin
user.profile = profile
user.save()
return user
def seed_users(num_of_users):
"""
Seed the database with users.
:param num_of_users: Number of users to seed the
database with, default is 50.
"""
print('Collecting users...')
try:
data = requests.get(
'https://randomuser.me/api/?'
f'results={num_of_users}'
'&inc=name,email,login,picture,dob,location,nat'
).json()
perms = Permission.query.all()
print('Saving to database...')
for user in data.get('results'):
u = User(password='******')
u.username = user.get('login')['username']
u.email = user.get('email')
u.created_on = random_timestamp(
datetime.datetime(2018, 7, 1), datetime.datetime(2019, 2, 28))
u.profile = Profile()
u.profile.name = user.get('name')['first'] + \
' ' + user.get('name')['last']
u.profile.avatar = user.get('picture')['thumbnail']
u.profile.dob = user.get('dob')['date']
u.profile.bio = f"Hi, I am {user.get('name')['first']} \
from {user.get('location')['city']} \
{user.get('location')['state']}, {user.get('nat')}. \
I am a {user.get('dob')['age']} yrs old, who likes \
to tell jokes."
u.profile.created_on = random_timestamp(
datetime.datetime(2019, 1, 1), datetime.datetime(2019, 6, 30))
u.permissions.extend(random.sample(
perms, k=random.randrange(len(perms))))
u.save()
print('Setting up followers/following...')
users = User.query.all()
for user in users:
following = random.sample(users, k=random.randrange(len(users)))
user.followed.extend(following)
user.save()
print(f'Users table seeded with {num_of_users} users...')
except exc.IntegrityError as error:
db.session.rollback()
print(f'Error: {error}')
def add_user(name,
email,
username='',
avatar='',
bio='',
is_admin=False,
is_active=True,
permissions=[]):
profile = Profile(name=name, bio=bio)
profile.avatar = avatar or profile.set_avatar(email)
user = User(password='******')
user.email = email
user.username = username
user.is_admin = is_admin
user.is_active = is_active
user.add_permissions(permissions)
user.profile = profile
user.save()
return user
def get_profile(user, username):
a_user = Profile.find_by_username(username).user
if a_user:
profile = UserSchema(only=(
'id',
'profile',
'followers',
'following',
)).dump(a_user)
if user.profile.username != username:
profile['isFollowing'] = user.is_following(a_user)
return jsonify(profile)
return not_found('User not found.')
def add_user(firstname='', lastname='', username='', email='',
is_admin=False, is_active=True):
p = Profile(firstname=firstname, lastname=lastname)
p.username = username or p.set_username()
p.avatar = p.set_avatar(email)
user = User(email=email, password='******', is_admin=is_admin,
is_active=is_active, profile=p)
user.save()
return user
def get_chat_messages(user):
username = request.args.get('username', '')
cursor = request.args.get('cursor')
items_per_page = current_app.config['ITEMS_PER_PAGE']
a_user = Profile.find_by_username(username).user
nextCursor = None
msgs = None
if not a_user:
return not_found('User not found.')
try:
query = user.get_chat_messages(a_user)
chat = user.get_chat(a_user)
if cursor == '0':
msgs = query.limit(items_per_page + 1).all()
else:
cursor = urlsafe_base64(cursor, from_base64=True)
msgs = query.filter(
Message.created_on < cursor).limit(items_per_page + 1).all()
if len(msgs) > items_per_page:
nextCursor = urlsafe_base64(msgs[items_per_page -
1].created_on.isoformat())
# check if lrm exist
if chat:
lrm = LastReadMessage.find_by_pk(user.id, chat.id)
if lrm:
lrm.timestamp = datetime.utcnow()
else:
lrm = LastReadMessage()
lrm.user_id = user.id
lrm.chat_id = chat.id
lrm.timestamp = datetime.utcnow()
lrm.save()
except Exception as e:
db.session.rollback()
print(e)
return server_error('Something went wrong, please try again.')
else:
return {
'data': MessageSchema(many=True).dump(msgs[:items_per_page]),
'nextCursor': nextCursor
}
def get_liked_posts(user, username):
"""Get a users list of liked posts"""
a_user = Profile.find_by_username(username).user
if not a_user:
return not_found('User not found.')
cursor = request.args.get('cursor')
items_per_page = current_app.config['ITEMS_PER_PAGE']
nextCursor = None
posts = None
try:
query = a_user.likes.order_by(Post.created_on.desc())
if cursor == '0':
posts = query.limit(items_per_page + 1).all()
else:
cursor = urlsafe_base64(cursor, from_base64=True)
posts = query.filter(
Post.created_on < cursor).limit(items_per_page + 1).all()
except (exc.IntegrityError, ValueError) as e:
db.session.rollback()
print(e)
return server_error('Something went wrong, please try again.')
if len(posts) > items_per_page:
nextCursor = urlsafe_base64(
posts[items_per_page - 1].created_on.isoformat())
liked_posts = []
for p in posts[:items_per_page]:
post = p.to_dict(user)
if p.parent:
post['parent'] = PostSchema(
only=('id', 'body', 'author',)).dump(p.parent)
liked_posts.append(post)
return {
'data': liked_posts,
'nextCursor': nextCursor,
'total': query.count(),
}
def add_user():
request_data = request.get_json()
if not request_data:
return bad_request("No input data provided")
try:
data = AuthSchema().load(request_data)
email = data.get('email')
password = data.get('password')
name = data.get('name')
username = data.get('username')
# check for existing user
user = User.query.filter((User.email == email)
| (User.username == username)).first()
if user is not None:
return bad_request('That user already exists.')
# add new user to db
profile = Profile(name=name)
user = User(password=password)
user.email = email
user.username = username
user.is_active = data.get('is_active') or False
user.is_admin = data.get('is_admin') or False
user.profile = profile
user.save()
response = jsonify(UserSchema().dump(user))
response.status_code = 201
response.headers['Location'] = url_for('admin.get_user', id=user.id)
return response
# handle errors
except ValidationError as err:
return error_response(422, err.messages)
except (exc.IntegrityError, ValueError):
db.session.rollback()
return server_error('Something went wrong, please try again.')
def get_followers(user, username):
"""Get list of users following a user"""
a_user = Profile.find_by_username(username).user
if not a_user:
return not_found('User not found.')
cursor = request.args.get('cursor')
items_per_page = current_app.config['ITEMS_PER_PAGE']
nextCursor = None
followers = None
try:
query = a_user.followers.order_by(User.id.desc())
if cursor == '0':
followers = query.limit(items_per_page + 1).all()
else:
cursor = int(urlsafe_base64(cursor, from_base64=True))
followers = query.filter(
User.id < cursor).limit(items_per_page + 1).all()
except (exc.IntegrityError, ValueError):
db.session.rollback()
return server_error('Something went wrong, please try again.')
else:
if len(followers) > items_per_page:
nextCursor = urlsafe_base64(str(followers[items_per_page - 1].id))
user_followers = []
for a_user in followers[:items_per_page]:
follower = UserSchema(only=('id', 'profile',)).dump(a_user)
follower['isFollowing'] = user.is_following(a_user)
user_followers.append(follower)
return {
'data': user_followers,
'total': query.count(),
'nextCursor': nextCursor,
}
def get_user_posts(user, username):
"""Get a users list of posts"""
a_user = Profile.find_by_username(username).user
if not a_user:
return not_found('User not found.')
cursor = request.args.get('cursor')
items_per_page = current_app.config['ITEMS_PER_PAGE']
nextCursor = None
posts = None
try:
query = Post.query.with_parent(a_user).filter(
Post.comment_id.is_(None)).order_by(Post.created_on.desc())
if cursor == '0':
posts = query.limit(items_per_page + 1).all()
else:
cursor = urlsafe_base64(cursor, from_base64=True)
posts = query.filter(
Post.created_on < cursor).limit(items_per_page + 1).all()
except (exc.IntegrityError, ValueError) as e:
db.session.rollback()
print(e)
return server_error('Something went wrong, please try again.')
if len(posts) > items_per_page:
nextCursor = urlsafe_base64(
posts[items_per_page - 1].created_on.isoformat())
return {
'data': [post.to_dict(user) for post in posts[:items_per_page]],
'nextCursor': nextCursor,
'total': query.count(),
}
def register_user():
request_data = request.get_json()
if not request_data:
return bad_request("No input data provided")
try:
data = AuthSchema().load(request_data)
except ValidationError as err:
return error_response(422, err.messages)
email = data.get('email')
password = data.get('password')
firstname = data.get('firstname').title()
lastname = data.get('lastname').title()
try:
# check for existing user
user = User.query.filter(User.email == email).first()
if user:
return bad_request('Sorry. That user already exists.')
# add new user to db
profile = Profile(firstname=firstname, lastname=lastname)
profile.username = profile.set_username()
profile.avatar = profile.set_avatar(email)
user = User(email=email, password=password, profile=profile)
user.save()
response = jsonify({
'token': user.encode_auth_token(user.id).decode(),
})
response.status_code = 201
response.headers['Location'] = url_for('auth.get_user', id=user.id)
return response
# handle errors
except (exc.IntegrityError, ValueError):
db.session.rollback()
return error_response(500, 'Something went wrong, please try again.')
def register_user():
post_data = request.get_json()
if not post_data:
return bad_request("No input data provided")
try:
data = AuthSchema(partial=True).load(post_data)
except ValidationError as err:
return error_response(422, err.messages)
name = data.get('name')
username = data.get('username')
email = data.get('email')
password = data.get('password')
# check for existing user
user = User.query.filter(User.email == email).first()
if user:
return bad_request('That user already exists.')
profile = Profile()
profile.name = name
profile.username = username
profile.avatar = profile.set_avatar(email)
user = User(password=password)
user.email = email
user.profile = profile
try:
user.save()
except (exc.IntegrityError, ValueError):
db.session.rollback()
return server_error('Something went wrong, please try again.')
response = jsonify({'token': user.encode_auth_token()})
response.status_code = 201
response.headers['Location'] = url_for('users.get_user', id=user.id)
return response