def save_image():
try:
data = request.get_json()
filename = os.path.join(os.path.dirname(__file__), 'image.jpeg')
with open(filename, 'wb') as f:
# get image data
image_data = data["imageData"]
image_data = base64.b64decode(image_data)
f.write(image_data)
userId = get_jwt_identity()
img = face_recognition.load_image_file(filename)
face_encodings = face_recognition.face_encodings(img)
if len(face_encodings) != 1:
print(face_encodings)
os.remove(filename)
return bad_request("There is no face in the photo.")
np.savetxt(
os.path.join(os.path.dirname(__file__), "encodings",
userId + ".txt"), face_encodings)
os.remove(filename)
return jsonify({"success": True})
except KeyError:
return bad_request("Wrong arguments.")
return bad_request(
"There is an internal server error. Please contact the IT support.")
def save_image():
try:
data = request.get_json()
# get user from jwt token
token = data["token"]
payload = jwt.decode(token,
open(current_app.config["JWT_KEY_PUBLIC"]).read(),
algorithms=['RS256'])
user = User.query.filter_by(id=payload["id"]).first()
if not user:
return bad_request("User does not exist.")
# get image data
image_data = data["imageData"]
image_data = base64.b64decode(image_data)
filename = os.path.join(os.path.dirname(__file__), 'image.jpg')
with open(filename, 'wb') as f:
f.write(image_data)
img = face_recognition.load_image_file(filename)
face_encodings = face_recognition.face_encodings(img)
if len(face_encodings) != 1:
return bad_request("There is no face in the photo.")
# put face encoding of the user into the database here
encoding_to_save = face_encodings[0].tostring()
user.save_face_encoding(encoding_to_save)
return jsonify({"success": True})
except KeyError:
return bad_request("Wrong arguments.")
return bad_request(
"There is an internal server error. Please contact the IT support.")
def signin():
try:
data = request.get_json()
username = data["username"]
password = data["password"]
query = loginQuery(username)
user = schema.execute(query, context_value={"accessLevel": 4})
user = user.data.get("user")
if user and len(user) != 1:
return bad_request("Incorrect username or password.")
user = user[0]
if User.checkPassword(user.get("password", None), password):
expires = timedelta(days=365)
accessToken = create_access_token(identity=user,
expires_delta=expires)
return jsonify({
"token":
accessToken,
"username":
user.get("username"),
"userId":
str(user.get("Id")),
"avatarUrl":
user.get("avatar"),
"userType":
user.get("accessLevel"),
"fullname":
user.get("firstname") + " " + user.get("lastname"),
"accessLevel":
user.get("accessLevel")
})
except KeyError:
return bad_request("Wrong arguments.")
return bad_request(
"There is an internal server error. Please contact the IT support.")
def signin():
try:
data = request.get_json()
username = data["username"]
password = data["password"]
user = User.query.filter_by(username=username).first()
if not user:
return bad_request("Incorrect username or password.")
if user and user.check_password(password):
public_key = open(current_app.config["JWT_KEY_PUBLIC"]).read()
private_key = open(current_app.config["JWT_KEY_PRIVATE"]).read()
token = jwt.encode({
"id": user.id,
"username": username,
}, private_key, algorithm="RS256").decode("utf-8")
user.login(token)
fullname = user.firstname + " " + user.lastname
return jsonify({
"token": token,
"success": True,
"avatarUrl": user.get_default_avatar(256),
"userType": user.access_level,
"fullname": fullname
})
except KeyError:
return bad_request("Wrong arguments.")
return bad_request("There is an internal server error. Please contact the IT support.")
def addStudents():
try:
data = request.get_json()
studentList = data["studentList"]
scheduleId = data["scheduleId"]
schedule = db.scheduleDetails.find_one({"_id": ObjectId(scheduleId)})
scheduleStudents = list(
map(lambda student: student["_id"], schedule["students"]))
for student in scheduleStudents:
if student in studentList:
studentList.remove(student)
db.scheduleDetails.update({"_id": ObjectId(scheduleId)}, {
"$push": {
"students": {
"$each":
list(
map(
lambda student: {
"_id": student,
"inClass": False,
"minsLate": 0
}, studentList))
}
}
})
return jsonify({"studentList": studentList})
except KeyError:
return bad_request("Wrong arguments.")
return bad_request(
"There is an internal server error. Please contact the IT support.")
def register():
try:
data = request.get_json()
username = data["username"]
password = data["password"]
password1 = data["password1"]
firstname = data["firstname"]
lastname = data["lastname"]
email = data["email"]
access_level = data["accessLevel"]
if access_level not in ["1", "2", 1, 2]:
return bad_request("Type is not correct.")
if (password != password1 or len(password) < 8 or not firstname
or not lastname or not email or not username):
return bad_request("Please check in with all the fields.")
user = User.query.filter_by(username=username).first()
if (user):
return bad_request("Username already exists.")
# when passed all the validations, add user in the database
user = User(username=username, email=email, firstname=firstname, lastname=lastname, access_level=int(access_level))
user.set_password(password)
db.session.add(user)
db.session.commit()
return jsonify({"success": True})
except KeyError:
return bad_request("Wrong arguments.")
return bad_request("There is an internal server error. Please contact the IT support.")
def getUserInfo():
try:
user = db.users.find_one({"_id": ObjectId(get_jwt_identity())})
return jsonify({"email": user["email"], "phone": user["phone"], "firstname": user["firstname"], "lastname": user["lastname"], "avatar": user["avatar"]})
except KeyError:
return bad_request("Wrong arguments.")
return bad_request("There is an internal server error. Please contact the IT support.")
def signout():
try:
data = request.get_json()
token = data["token"]
return jsonify({})
except KeyError:
return bad_request("Wrong arguments.")
return bad_request(
"There is an internal server error. Please contact the IT support.")
def searchUser():
try:
data = request.get_json()
searchPattern = data["searchPattern"]
users = list(db.users.find({"username": {"$regex": searchPattern}}))
users = list(map(lambda user: {"_id": str(
user["_id"]), "firstname": user["firstname"], "lastname": user["lastname"], "avatar": user["avatar"]}, users))
return jsonify({"data": users})
except KeyError:
return bad_request("Wrong arguments.")
return bad_request("There is an internal server error. Please contact the IT support.")
def signout():
try:
data = request.get_json()
token = data["token"]
payload = jwt.decode(token, open(current_app.config["JWT_KEY_PUBLIC"]).read(), algorithms=['RS256'])
user = User.query.filter_by(id=payload["id"]).first()
user.logout()
return jsonify({"success": True})
except KeyError:
return bad_request("Wrong arguments.")
return bad_request("There is an internal server error. Please contact the IT support.")
def editBio():
try:
data = request.get_json()
userId = data["userId"]
bio = data["bio"]
db.users.update_one({"_id": ObjectId(userId)}, {"$set": {"bio": bio}})
return jsonify({"bio": bio})
except KeyError:
return bad_request("Wrong arguments.")
return bad_request("There is an internal server error. Please contact the IT support.")
def duplicate_user():
try:
data = request.get_json()
username = data["username"]
user = User.query.filter_by(username=username).first()
if user:
return jsonify({"duplicate": True})
return jsonify({"duplicate": False})
except KeyError:
return bad_request("Wrong arguments.")
return bad_request("There is an internal server error. Please contact the IT support.")
def duplicate_user():
try:
data = request.get_json()
username = data["username"]
user = schema.execute(loginQuery(username))
if len(user.data.get("user")) != 0:
return jsonify({"duplicate": True})
return jsonify({"duplicate": False})
except KeyError:
return bad_request("Wrong arguments.")
return bad_request(
"There is an internal server error. Please contact the IT support.")
def wrapper(*args, **kwargs):
verify_jwt_in_request()
claims = get_jwt_claims()
if int(claims['role']) < 1:
return bad_request("You don't have enough access")
else:
return fn(*args, **kwargs)
def get_message():
try:
data = request.get_json()
# get user from jwt token
token = data["token"]
payload = jwt.decode(token,
open(current_app.config["JWT_KEY_PUBLIC"]).read(),
algorithms=['RS256'])
user = User.query.filter_by(id=payload["id"]).first()
if not user:
return bad_request("User does not exist.")
# type 1: get all users
message_type = data["messageType"]
if message_type == 1:
users = User.query.all()
data_to_return = []
for user in users:
data_to_return.append({
"id": user.id,
"fullname": user.firstname + " " + user.lastname,
"accessLevel": user.access_level,
"avatar": user.get_default_avatar(512)
})
return jsonify({"results": data_to_return})
except KeyError:
pass
def send_message():
try:
# get user id and other id
data = request.get_json()
payload = jwt.decode(data["token"],
open(current_app.config["JWT_KEY_PUBLIC"]).read(),
algorithms=['RS256'])
user_id = payload["id"]
other_id = data["id"]
# sanity check if two users exist
user = User.query.filter_by(id=user_id).first()
user1 = User.query.filter_by(id=other_id).first()
if not user or not user1:
return bad_request("User does not exist.")
# send message
content = data["content"]
if not content:
return bad_request("Message contains no content.")
user.send_message(user1, content)
# get all the messages to return
messages = Message.query.filter(or_(and_(Message.from_id==user_id, Message.to_id==other_id), \
and_(Message.from_id==other_id, Message.to_id==user_id))).order_by(Message.timestamp.desc()).all()
results = []
for message in messages:
if message.from_id == user_id:
results.append({
"id": message.id,
"content": message.content,
"self": True
})
else:
results.append({
"id": message.id,
"content": message.content,
"self": False
})
return jsonify({"results": results})
except KeyError:
pass
def upload():
try:
data = request.get_json()
image_data = data["imageData"]
image_data = image_data[image_data.find(",") + 1:]
image_data = base64.b64decode(image_data)
filename = 'image.jpg'
with open(filename, 'wb') as f:
f.write(image_data)
# Load the uploaded image file
img = face_recognition.load_image_file(filename)
face_locations = face_recognition.face_locations(img)
# Get face encodings for any faces in the uploaded image
unknown_face_encodings = face_recognition.face_encodings(img)
people_found = []
users = User.query.all()
if len(unknown_face_encodings) > 0:
# get only those users have face encoding
known_face_encodings = []
users_have_encodings = []
for u in users:
if u.face_encoding:
known_face_encodings.append(np.fromstring(u.face_encoding))
users_have_encodings.append(u)
# compare faces
match_results = face_recognition.compare_faces(
known_face_encodings, unknown_face_encodings[0])
# get the name of all users that have the same face encodings
for i in enumerate(match_results):
if (i[1]):
people_found.append(users_have_encodings[i[0]].firstname +
" " +
users_have_encodings[i[0]].lastname)
return jsonify({"success": True, "peopleFound": people_found})
except KeyError:
return bad_request("Wrong arguments.")
return bad_request(
"There is an internal server error. Please contact the IT support.")
def get_emoji():
try:
data = request.get_json()
sentence = data["sentence"]
# get pre-intialized graph and model
global emojifier_model, graph
embeddings = prepare_sentence(sentence)
# create new graph and get predictions
emojis = {}
with graph.as_default():
predict_val = emojifier_model.predict(embeddings)
for i in range(int(3)):
max_idx = np.argmax(predict_val)
predict_val[0, max_idx] = -1
emojis[str(i)] = label_to_emoji(max_idx)
return jsonify({"emojis": emojis})
except KeyError:
return bad_request("Wrong arguments")
def upload():
try:
data = request.get_json()
# the student list that hasn't been marked
studentList = data["studentList"]
if not studentList:
return jsonify({"studentList": []})
scheduleId = data["scheduleId"]
userId = data["userId"]
# get image data
image_data = data["imageData"]
image_data = image_data.split(",")[1]
image_data = base64.b64decode(image_data)
filename = os.path.join(os.path.dirname(__file__), 'image.jpeg')
with open(filename, 'wb') as f:
f.write(image_data)
# Load the uploaded image file
img = face_recognition.load_image_file(
os.path.join(os.path.dirname(os.path.realpath(__file__)),
filename))
# Get face encodings for any faces in the uploaded image
unknown_face_encodings = face_recognition.face_encodings(img)
people_found = []
if len(unknown_face_encodings) > 0:
# get only those users have face encoding
users_have_encodings = []
for student in studentList:
try:
student_encoding = np.loadtxt(
os.path.join(os.path.dirname(__file__), "encodings",
student + ".txt"))
users_have_encodings.append({
"student": student,
"encoding": student_encoding
})
except OSError:
pass
# compare faces
match_results = face_recognition.compare_faces(
[student["encoding"] for student in users_have_encodings],
unknown_face_encodings[0])
# get the name of all users that have the same face encodings
for index, result in enumerate(match_results):
if (result):
user = users_have_encodings[index]
people_found.append(user["student"])
if (people_found):
studentUpdated = []
for i in people_found:
result = db.scheduleDetails.update(
{
"_id": ObjectId(scheduleId),
"students._id": i,
"students.inClass": False
}, {"$set": {
"students.$.inClass": True
}})
if (result["nModified"] > 0):
studentUpdated.append(i)
now = datetime.now()
if (studentUpdated):
activity = {
"activityType": 1,
"userId": userId,
"students": studentUpdated,
"timestamp": now
}
insertedId = db.activities.insert_one(activity).inserted_id
activity["Id"] = str(insertedId)
del activity["_id"]
activity["timestamp"] = str(now).split(".")[0]
return jsonify({
"studentList": studentUpdated,
"activity": activity
})
return jsonify({"studentList": []})
except KeyError:
return bad_request("Wrong arguments.")
return bad_request(
"There is an internal server error. Please contact the IT support.")
def register():
try:
data = request.get_json()
username = data["username"]
password = data["password"]
password1 = data["password1"]
firstname = data["firstname"]
lastname = data["lastname"]
email = data["email"]
accessLevel = data["accessLevel"]
dob = data["dob"]
gender = data["gender"]
data["phone"] = data["prefix"] + data["phone"]
if accessLevel not in ["1", "2", 1, 2]:
return bad_request("Type is not correct.")
if (password != password1 or len(password) < 8 or not firstname
or not lastname or not email or not username):
return bad_request("Please check in with all the fields.")
user = schema.execute(loginQuery(username))
if len(user.data.get("user")) != 0:
return bad_request("User already exists.")
u = User(**data)
u.setPassword(data["password"])
inserted_id = str(
db.users.insert_one({
"username": u.username,
"password": u.password,
"firstname": u.firstname,
"lastname": u.lastname,
"email": u.email,
"accessLevel": u.accessLevel,
"avatar": u.avatar,
"gender": data["gender"],
"dob": u.dob,
"studentClassroom": [],
"activities": [],
"phone": data["phone"],
}).inserted_id)
timestamp = datetime.utcnow()
inserted_id = str(
db.chatrooms.insert_one({
"users": [inserted_id],
"timestamp": timestamp,
"name": "Team @ School"
}).inserted_id)
avatar_digest = md5(
"*****@*****.**".lower().encode('utf-8')).hexdigest()
db.messages.insert_one({
"messageContent":
"Hello, welcome to @ School!",
"chatroomId":
inserted_id,
"senderId":
"",
"timestamp":
timestamp,
"senderAvatar":
'https://www.gravatar.com/avatar/{}?d=identicon&s={}'.format(
avatar_digest, 512)
})
return jsonify({})
except KeyError:
return bad_request("Wrong arguments.")
return bad_request(
"There is an internal server error. Please contact the IT support.")
