def update_user(id):
request_data = request.get_json()
if not request_data:
return bad_request("No input data provided")
try:
data = ProfileSchema().load(request_data)
user = User.find_by_id(id)
existing_user = User.find_by_identity(data.get('auth')['username'])
if existing_user is not None:
if existing_user.id != user.id:
return bad_request(f'Username already exists.')
# update user
user.profile.name = data.get('name')
user.profile.bio = data.get('bio')
user.profile.dob = data.get('dob')
user.username = data.get('auth')['username']
user.is_active = data.get('auth')['is_active']
user.is_admin = data.get('auth')['is_admin']
user.save()
return jsonify(UserSchema().dump(user))
# 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_profile(user, username):
user = User.find_by_identity(username)
if user:
return jsonify(UserSchema().dump(user))
return not_found('User not found.')
def get_users_to_follow(user):
"""Recommend users to follow"""
try:
users = user.get_users_to_follow()
except (exc.IntegrityError, ValueError):
db.session.rollback()
return server_error('Something went wrong, please try again.')
return jsonify(UserSchema(
many=True, only=('id', 'profile',)).dump(users))
def to_dict(self, user):
followers = []
count = 0
if len(self.users) == 1 or len(self.users) == 2:
followers = UserSchema(
many=True, only=('id', 'profile',)).dump(user)
if len(self.users) > 2:
followers = UserSchema(many=True, only=('id', 'profile',)).dump(
random.sample(self.users, k=2))
count = len(self.users) - 2
return {
'id': self.id,
'name': self.name,
'isFollowing': user.is_following_tag(self),
'followedBy': {'users': followers, 'count': count}
}
def remove_user_permissions(id):
data = request.get_json()
user = User.find_by_id(id)
perms = []
for id in data.get('perms'):
perm = Permission.find_by_id(id)
perms.append(perm)
user.remove_permissions(perms)
return jsonify(UserSchema().dump(user))
def get_users(page=1):
"""Get list of users"""
users = User.query.paginate(page, current_app.config['ITEMS_PER_PAGE'],
False)
next_url = url_for('admin.get_users', page=users.next_num) \
if users.has_next else None
prev_url = url_for('admin.get_users', page=users.prev_num) \
if users.has_prev else None
return {
'items': UserSchema(many=True).dump(users.items),
'next_url': next_url,
'prev_url': prev_url
}
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 get_followers(user, username, page=1):
"""Get list of users following a user"""
user = User.find_by_identity(username)
try:
followers = user.followers.paginate(
page, current_app.config['ITEMS_PER_PAGE'], False)
except (exc.IntegrityError, ValueError):
db.session.rollback()
return server_error('Something went wrong, please try again.')
else:
return {
'followers': UserSchema(many=True, only=(
'id', 'username', 'profile',)).dump(followers.items),
'count': user.followers.count(),
'hasNext': followers.has_next,
}
def unfollow(user, id):
followed = User.find_by_id(id)
if not followed:
return not_found('User not found')
user.unfollow(followed)
try:
user.save()
except (exc.IntegrityError, ValueError):
db.session.rollback()
return server_error('Something went wrong, please try again.')
else:
return jsonify(UserSchema(
many=True, only=('id',)).dump(user.followed.all()))
def msg_Search(user):
q = request.args.get('q', str, None)
try:
if q is None:
return {[]}
users = User.search(UsersIndex, q)
except Exception as e:
db.session.rollback()
print(e)
return server_error('An unexpected error occured, please try again.')
return {
'users':
UserSchema(many=True,
only=('id', 'auth.username', 'profile.name',
'profile.avatar')).dump(users),
}
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 follow(user, id):
to_follow = User.find_by_id(id)
if not to_follow:
return not_found('User not found')
user.follow(to_follow)
db.session.add(
user.add_notification(
subject='follow', item_id=user.id, id=to_follow.id))
try:
user.save()
except (exc.IntegrityError, ValueError):
db.session.rollback()
return server_error('Something went wrong, please try again.')
else:
following = UserSchema(only=('id', 'profile',)).dump(to_follow)
following['isFollowing'] = user.is_following(to_follow)
return jsonify(following)
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_messages(user):
cursor = request.args.get('cursor')
items_per_page = current_app.config['ITEMS_PER_PAGE']
last_messages = None
nextCursor = None
messages = []
try:
stmt, query = user.get_chat_last_messages()
if cursor == '0':
last_messages = query.limit(items_per_page + 1).all()
else:
cursor = urlsafe_base64(cursor, from_base64=True)
last_messages = query.filter(
stmt.c.last_messages < cursor).limit(items_per_page + 1).all()
except (IntegrityError, ValueError) as e:
db.session.rollback()
print(e)
return server_error('Something went wrong, please try again.')
if len(last_messages) > items_per_page:
nextCursor = urlsafe_base64(last_messages[items_per_page -
1].last_messages.isoformat())
for msg, user1, user2, _ in last_messages[:items_per_page]:
author = user2 if user.id == user1.id else user1
last_read_msg = user.last_read_msg_ts(msg.chat_id)
message = MessageSchema(exclude=('author_id', )).dump(msg)
message['isRead'] = False if not last_read_msg else \
last_read_msg.timestamp >= msg.created_on
message['user'] = UserSchema(only=(
'id',
'profile',
)).dump(author)
messages.append(message)
return {
'data': messages,
'nextCursor': nextCursor,
}
def unfollow(user, id):
followed = User.find_by_id(id)
if not followed:
return not_found('User not found')
user.unfollow(followed)
notif = Notification.find_by_attr(subject='follow', item_id=user.id)
if (notif):
db.session.delete(notif)
try:
user.save()
except (exc.IntegrityError, ValueError):
db.session.rollback()
return server_error('Something went wrong, please try again.')
else:
follow = UserSchema(only=('id', 'profile',)).dump(followed)
follow['isFollowing'] = user.is_following(followed)
return jsonify(follow)
def mainSearch(user):
q = request.args.get('q', str, None)
try:
if q is None:
return {[]}
tags = Tag.search(TagsIndex, q)
users = User.search(UsersIndex, q)
except Exception as e:
db.session.rollback()
print(e)
return server_error('An unexpected error occured, please try again.')
return {
'results': {
'tags': [tag.to_dict(user) for tag in tags],
'users':
UserSchema(many=True,
only=('id', 'profile.username', 'profile.name',
'profile.avatar')).dump(users),
}
}
def get_user(id):
"""Get a single user"""
user = User.find_by_id(id)
if user is None:
return not_found('User not found!')
return jsonify(UserSchema().dump(user))
def get_user(user):
return jsonify(UserSchema(only=(
'id',
'profile',
)).dump(user))
def get_all_followers(user):
return jsonify(UserSchema(many=True, only=('id',)).dump(user.followers))
