def accept_friend_request(self, sender, dest):
sender_doc = self.__get_user_doc(sender)
sender_dict = sender_doc.get().to_dict()
if sender_dict is None: return response(404, "sender not found")
dest_doc = self.__get_user_doc(dest)
dest_dict = dest_doc.get().to_dict()
if dest_dict is None: return response(404, "dest not found")
dest_friends = dest_dict['friends']
if sender not in dest_friends or dest_friends[sender] == True:
return response(
403,
"there is no pending friend request between sender and dest")
sender_friends = sender_dict['friends']
channel = 'chan_' + sender_dict['username'] + '_' + dest_dict[
'username']
temp = dest_friends[sender]
temp['is_friends'] = True
temp['channel'] = channel
dest_friends[sender] = temp
dest_doc.set({'friends': dest_friends}, merge=True)
sender_friends[dest] = {
'username': dest_dict['username'],
'pp': dest_dict['pp'],
'is_friends': True,
'channel': channel,
}
sender_doc.set({'friends': sender_friends}, merge=True)
return response(201, sender)
def delete_friend_or_friend_request(self, uid, friend):
user_doc = self.__get_user_doc(uid)
user_dict = user_doc.get().to_dict()
if user_dict is None: return response(404, "user not found")
friend_doc = self.__get_user_doc(friend)
friend_dict = friend_doc.get().to_dict()
user_friends = user_dict['friends']
if friend not in user_friends:
return response(
403,
"friend isn't a friend of user or there is no pending friend request between them"
)
friend_friends = friend_dict['friends']
user_friends.pop(friend)
temp = user_dict
temp['friends'] = user_friends
user_doc.set(temp)
if uid in friend_friends:
friend_friends.pop(uid)
temp = friend_dict
temp['friends'] = friend_friends
friend_doc.set(temp)
return response(200, friend)
def send_friend_request(self, sender, dest):
sender_doc = self.__get_user_doc(sender)
sender_dict = sender_doc.get().to_dict()
if sender_dict is None: return response(404, "sender not found")
dest_uid = self.__get_user_uid(dest)
if dest_uid is None: return response(404, "dest not found")
dest_doc = self.__get_user_doc(dest_uid)
dest_dict = dest_doc.get().to_dict()
if dest_dict is None: return response(404, "dest not found")
dest_friends = dest_dict['friends']
if sender in dest_friends:
return response(
403,
"sender is already friends with dest or there is already a pending friend request between them"
)
dest_friends[sender] = {
'username': sender_dict['username'],
'pp': sender_dict['pp'],
'is_friends': False,
}
dest_doc.set({'friends': dest_friends}, merge=True)
return response(201, dest_uid)
def delete_friend_or_friend_request():
if 'uid' in request.args and 'friend' in request.args:
uid = request.args['uid']
friend = request.args['friend']
if uid == friend:
return response(400, "uid and friend can't be the same")
return db.delete_friend_or_friend_request(uid, friend)
return response(
400, "uid: user that's deleting a friend"
"friend: user that's being deleted")
def send_friend_request():
json_data = request.get_json()
if 'sender' in json_data and 'dest' in json_data:
sender = json_data['sender']
dest = json_data['dest']
if sender == dest:
return response(400, "sender and dest can't be the same")
return db.send_friend_request(sender, dest)
return response(
400, "sender: user sending friend request"
"dest: user the friend request is being sent to")
def update_user_pp(self, uid, encoded_pp):
try:
pp_link = self.__upload_user_pp(uid, encoded_pp)
except TypeError as te:
return response(403, str(te))
user_doc = self.__get_user_doc(uid)
pp = {'pp': pp_link}
user_doc.update(pp)
return response(201, pp)
def accept_friend_request():
json_data = request.get_json()
if 'sender' in json_data and 'dest' in json_data:
sender = json_data['sender']
dest = json_data['dest']
if sender == dest:
return response(400, "sender and dest can't be the same")
return db.accept_friend_request(sender, dest)
return response(
400, "sender: user that sent the friend request"
"dest: user that is accepting the friend request")
def create_group(self, name):
if name in self.__get_group_list():
return response(403, "group already exists")
group = {
'name': name,
'msg': [],
}
doc_ref = self.__db.collection('groups').document(name)
doc_ref.set(group)
return response(201, group)
def grant_token():
if 'Authorization' in request.headers and request.headers['Authorization'].split(' ')[0] == 'Bearer':
raw_token = request.headers['Authorization']
token = raw_token.split(' ')[1]
decoded_token = db.auth.verify_id_token(token)
if not decoded_token:
return response(403, 'Unauthorized')
channels = [friend.channel for friend in db.get_all_friends()]
channels.append(db.get_all_groups())
pubnub.grant()\
.auth_keys(token)\
.channels(channels)\
.read(True)\
.write(True)
return 'true'
return response(400, 'No valid Authorization token was found')
def get_user_pp(): if 'uid' in request.args: uid = request.args['uid'] return db.get_user_pp(uid) return response( 400, "uid: uid of owner of the pic" )
def send_message(self, name, msg, uid, username, time, pp):
group_ref = self.__db.collection('groups').document(name)
group = group_ref.get().to_dict()
if group:
message = {
'data': msg,
'uid': uid,
'username': username,
'time': time,
'pp': pp
}
messages = group['msg']
messages.append(message)
group_ref.set({'msg': messages}, merge=True)
return response(200, message)
return response(404, "group not found")
def create_group(): json_data = request.get_json() if 'name' in json_data: name = json_data['name'] return db.create_group(name) return response( 400, "name: name of group being created" )
def update_user_pp(): json_data = request.get_json() if 'uid' in json_data and 'encoded_pp' in json_data: uid = json_data['uid'] encoded_pp = json_data['encoded_pp'] return db.update_user_pp(uid, encoded_pp) return response( 400, "uid: uid of owner of the pic" "path: path to the file" )
def create_user(self, username, email, pw, encoded_pp=None):
if not self.__is_user_unique(username):
return response(403, "username already exists")
try:
user_record = self.auth.create_user(email=email, password=pw)
except firebase_admin._auth_utils.EmailAlreadyExistsError:
return response(403, "user already exists")
uid = user_record.uid
user = {
'uid': uid,
'username': username,
'friends': {},
'pp': self.__upload_user_pp(uid, encoded_pp) if encoded_pp else ''
}
user_doc = self.__get_user_doc(uid)
user_doc.set(user)
return response(201, user)
def create_user():
json_data = request.get_json()
if 'username' in json_data and 'email' in json_data and 'pw' in json_data:
username = json_data['username']
email = json_data['email']
pw = json_data['pw']
pp_path = json_data.get('pp', None)
return db.create_user(username, email, pw, pp_path)
return response(
400,
"username: username of user being created"
"email: email of user being created"
"pw: password of user being created"
"(optional) path: path of the file to upload"
)
def send_message():
json_data = request.get_json()
if 'name' in json_data and 'msg' in json_data and 'uid' in json_data and 'username' in json_data and "time" in json_data:
name = json_data['name']
msg = json_data['msg']
uid = json_data['uid']
username = json_data['username']
time = json_data['time']
pp = json_data.get('pp', None)
return db.send_message(name, msg, uid, username, time, pp)
return response(
400,
"name: name of group"
"msg: message content"
"uid: uid of user sending message"
"username: username of user being created"
"(optional) pp: url of profile picture"
)
def get_group(self, name):
group_ref = self.__db.collection('groups').document(name)
group = group_ref.get().to_dict()
if group: return response(200, group)
return response(404, "group not found")
def get_user(self, uid):
user_doc = self.__get_user_doc(uid)
user = user_doc.get().to_dict()
if user: return response(200, user)
return response(404, "user not found")
def get_group(): if 'name' in request.args: name = request.args['name'] return db.get_group(name) return response(400, "name: name of requested group")
def get_user_pp(self, uid):
user_doc = self.__get_user_doc(uid)
pp_link = user_doc.get(['pp']).to_dict()
if pp_link: return response(200, pp_link)
return response(404, "user not found")
def get_all_friends(self, uid):
user_doc = self.__get_user_doc(uid)
friends = user_doc.get(['friends']).to_dict()
if friends: return response(200, friends)
return response(404, "user not found")
def get_all_groups(self):
return response(200, self.__get_group_list())
def get_user_uid(): if 'username' in request.args: username = request.args['username'] return db.get_user_uid(username) return response(400, "username: username of requested user")
def get_user(): if 'uid' in request.args: uid = request.args['uid'] return db.get_user(uid) return response(400, "uid: uid of requested user")
def home():
return response(200, "This is the InkChat server")
def get_all_friends():
if 'uid' in request.args:
uid = request.args['uid']
return db.get_all_friends(uid)
return response(400, "uid: user to get all friends from")
