def username_available(username, user, session):
users = User.find_username(username)
groups = Group.find_username(username)
available = not users and not groups
return response({'username': username, 'available': available})
def find_group(username, user, session):
group = Group.find(username=username)
if not group:
abort(404)
return response({'group': group.make_json()})
def logout(user, session):
"""
logout and delete a previous session token
"""
session.delete()
return response({'logged_out': True})
def block_user(username, user, session):
target = User.find(username=username)
if not user:
abort(404)
user.block(target)
return response({'blocked': True})
def join_group(username, user, session):
group = Group.find(username=username)
if not group:
abort(404)
group.add_user(user)
ChatController.user_joined_group(group, user)
return response({'joined': True, 'group': group.make_json()})
def search_username(username, user, session):
users = User.find_username(username)
groups = Group.find_username(username)
return response({
'groups': [group.make_json(include_members=False) for group in groups],
'users': [user.make_json() for user in users]
})
def send_message(user, session):
json = request.json
schema = Schema({'to': str, 'text': str})
try:
schema.validate(json)
except SchemaError as err:
return response(err.code)
to = json['to']
text = json['text']
try:
ChatController.new_msg(user.id, to, text)
except Exception as err:
return error_response(str(err))
return response({'sent': True})
def create_group(user, session):
json = request.json
schema = Schema({'title': str, 'username': str})
try:
schema.validate(json)
except SchemaError as err:
return response(err.code)
title = json['title']
username = json['username']
users = User.find_username(username)
groups = Group.find_username(username)
if users or groups:
return error_response('username has been already taken')
group = Group.new(user.id, title, username)
return response({'group': group.make_json()})
def friend_user(username, user, session):
friend = User.find(username=username)
if not user:
abort(404)
if friend.is_blocked(user):
return error_response('you have been blocked by user')
user.friend(friend)
return response({'added': True, 'friend': friend.make_json()})
def unblock_user(username, user, session):
target = User.find(username=username)
if not user:
abort(404)
if not user.is_blocked(target):
return error_response('user is not blocked')
user.unblock(target)
return response({'unblocked': True})
def unfriend_user(username, user, session):
friend = User.find(username=username)
if not user:
abort(404)
if not user.is_friends(friend):
return error_response('user is not a friend')
user.unfriend(friend)
return response({'unfriended': True})
def leave_group(username, user, session):
group = Group.find(username=username)
if not group:
abort(404)
if not group.has_user(user):
return error_response('you are not a member of this group')
group.remove_user(user)
ChatController.user_left_group(group, user)
return response({'joined': True, 'group': group.make_json()})
def register():
"""
verify user's phone number and
authenticate with a new token
:return:
"""
json = request.json
schema = Schema(
{
"first_name": str,
"username": str,
"token": str,
"phone": str,
Optional('last_name'): str
},
ignore_extra_keys=True)
try:
schema.validate(request.json)
except SchemaError as err:
return response(err.code)
last_name = None
if 'last_name' in json:
last_name = json['last_name']
first_name = json['first_name']
username = json['username']
token = json['token']
phone = json['phone']
if User.find(username=username):
return error_response("username already exists")
if not TextAPI.verify_auth(phone, token):
return error_response('invalid phone authentication')
user = User.new(first_name, last_name, username, phone)
session = Session.new(user.id)
return response({'user': user.make_json(), 'session': session.make_json()})
def login():
"""
verify user's phone number and login
the user
"""
json = request.json
schema = Schema({"token": str, "phone": str}, ignore_extra_keys=True)
try:
schema.validate(request.json)
except SchemaError as err:
return response(err.code)
token = json['token']
phone = json['phone']
if not TextAPI.verify_auth(phone, token):
return error_response('invalid phone authentication')
user = User.find(phone_num=phone)
if not user:
return error_response('user is not registered')
session = Session.new(user.id)
return response({'user': user.make_json(), 'session': session.make_json()})
def get_my_account(user, session):
return response({'user': user.make_json(True, True)})
def get_my_groups(user, session):
groups = Group.objects.filter(members=user.id)
return response({'groups': [group.make_json() for group in groups]})
def find_user(username, user, session):
user = User.find(username=username)
if not user:
abort(404)
return response({'user': user.make_json()})
def get_my_updates(user, session):
messages = Message.objects.filter(recipient_id=user.id)
messages_data = [message.make_json() for message in messages]
[message.delete() for message in messages]
return response({'messages': messages_data})
def get_my_friends(user, session):
users = User.objects.filter(id__in=user.friends)
return response({'friends': [user.make_json() for user in users]})
def get_my_blocked(user, session):
users = User.objects.filter(id__in=user.blocked)
return response({'blocked': [user.make_json() for user in users]})