def post(self):
param = {
'username': fields.String(),
'password': fields.String(),
'email': fields.String()
}
try:
json_data = parse_req(param)
username = json_data.get('username', None)
password = json_data.get('password', None)
email = json_data.get('email', None)
except Exception:
return jsonify("An error occurred when getting data !")
query_user = {
'_id': str(ObjectId()),
'username': username,
'password': password,
'email': email,
'first_login': True
}
try:
find_person = mycol.find_one({'username': username})
if find_person is not None:
return jsonify("Username is already exist")
if check_email(email) is None:
return jsonify("Invalidate email !")
else:
mycol.insert_one(query_user)
return jsonify("Register successfully !")
except Exception:
return jsonify("An error occurred when inserting data !")
def post(self):
param = {'username': fields.String(), 'password': fields.String()}
try:
json_data = parse_req(param)
username = json_data.get('username', None)
password = json_data.get('password', None)
except Exception:
return jsonify("An error occurred when getting data !")
user = mycol.find_one({'username': username})
if not safe_str_cmp(user['password'], password):
return jsonify("Your password is wrong!")
access_token = create_access_token(identity=str(user['_id']),
expires_delta=ACCESS_EXPIRES)
fresh_token = create_refresh_token(identity=str(user['_id']),
expires_delta=FRESH_EXPIRES)
dict1 = {
'access_token': access_token,
'fresh_token': fresh_token,
'message': 'Login Successfully !'
}
user_token = dict(_id=str(ObjectId()),
person_id=user['_id'],
access_token=access_token,
fresh_token=fresh_token)
mycol1.insert_one(user_token)
if user['first_login'] is True:
return jsonify(dict1)
return jsonify(dict1)
def update_data_by_id():
"""
This method should update a post by its id in db
:return: a notification of successful or error
"""
param_id = request.args.get('_id', None)
query_id = {
'_id': param_id
}
find_id = news.find(query_id)
if find_id is None:
return jsonify("_id doesn't exist!")
params = {
'title': fields.String(),
'content': fields.String()
}
json_data = parse_req(params)
try:
title = json_data.get('title', None)
content = json_data.get('content', None)
except:
return jsonify("Error occur when getting data !")
new_param = {
'$set': {
'title': title,
'content': content
}
}
try:
result = news.update_one(query_id, new_param)
return send_result(result)
except:
return send_error(code=500)
def add_post():
"""
This method should add a new post in db
:return: a notification of successful or errors
"""
params = {
'title': fields.String(),
'content': fields.String()
}
json_data = parse_req(params)
content = json_data.get("content", None)
if check_input(content):
return send_error(code=406, message="Content contains special characters")
title = json_data.get('title', None)
if check_input(title):
return send_error(code=406, message="Title contains special characters")
query_data = {
'_id': str(ObjectId()),
'title': title,
'content': content
}
try:
result = news.insert(query_data)
return send_result(result)
except:
return send_error(code=400)
def login():
"""
This methods uses to login in order to gain access token
:return: access token
"""
param = {'username': fields.String(), 'password': fields.String()}
try:
json_data = parse_req(param)
username = json_data.get('username', None)
password = json_data.get('password', None)
except:
return jsonify("An error occurred when getting data !")
user = userRegister.find_one({'username': username})
if not safe_str_cmp(user['password'], password):
return jsonify("Your password is wrong!")
access_token = create_access_token(identity=str(user['_id']),
expires_delta=ACCESS_EXPIRES)
dict1 = {'access_token': access_token, 'message': 'Login Successfully !'}
user_token = dict(
_id=str(ObjectId()),
person_id=user['_id'],
access_token=access_token,
)
Token.insert_one(user_token)
return jsonify(dict1)
def post(self):
"""
:variable: name, age, course, name_class
:return:
description: This method should create information of people
"""
# person_id = request.args.get('_id', None)
# query = {
# '_id': person_id
# }
# find_person = mycol2.find_one(query)
# if find_person is None:
# return jsonify("No data !")
#
# if find_person['group_id'] != '1':
# return jsonify("You don;t have permission to manipulate this performance !")
param = {
'name': fields.String(),
'age': fields.Number(),
'course': fields.String(),
'number_student': fields.String(),
'name_class': fields.String(),
'group_id': fields.String(),
'email': fields.String()
}
try:
json_data = parse_req(param)
name = json_data.get('name', None)
age = json_data.get('age', None)
course = json_data.get('course', None)
number_student = json_data.get('number_student', None)
name_class = json_data.get('name_class', None)
group_id = json_data.get('group_id', None)
email = json_data.get('email', None)
except Exception as e:
return jsonify("An error occurred when getting data")
query_user = {
'_id': str(ObjectId()),
'name': name,
'age': int(age),
'course': course,
'number_student': number_student,
'name_class': name_class,
'file_avatar': None,
'thumbnail': PATH_AVATAR_SERVER + AVATAR_DEFAULT,
'group_id': group_id,
'email': email
}
try:
mycol2.insert_one(query_user)
return jsonify("Insert Successfully !")
except Exception:
return jsonify("An error occurred when inserting data")
def put(self):
"""
:variable: name, age, course, name_class
:return:
description: This method should update information of people
"""
person_id = request.args.get('_id', None)
query = {'_id': person_id}
find_person = mycol2.find_one(query)
if find_person is None:
return jsonify("No data !")
if find_person['group_id'] != '1':
return jsonify(
"You don;t have permission to manipulate this performance !")
person_id = request.args.get('_id', None)
param = {
'name': fields.String(),
'age': fields.Number(),
'course': fields.String(),
'number_student': fields.String(),
'name_class': fields.String()
}
try:
json_data = parse_req(param)
name = json_data.get('name', None)
age = json_data.get('age', None)
number_student = json_data.get('number_student', None)
course = json_data.get('course', None)
name_class = json_data.get('name_class', None)
except Exception as e:
return {e}
query = {'_id': person_id}
try:
find_person = mycol2.find_one(query)
if find_person is None:
return jsonify("No data !")
except Exception:
return jsonify("An error occurred when finding data !")
new_query = {
'$set': {
'name': name,
'age': int(age),
'course': course,
'number_student': number_student,
'name_class': name_class
}
}
try:
mycol2.update_one(query, new_query)
return jsonify("Update successfully !")
except Exception:
return jsonify("An error occurred when updating data")
def thread_handler(self, client_sock, address):
size = 1024
data = ""
transfer = client_sock.recv(size)
data = data + transfer.decode('utf-8')
req = parse_req(data)
resp = call_api(req, self.cache, self.lsmtree, self.lock, self.fine_grained_lock)
client_sock.send(resp.encode('utf-8'))
#self.cache.show()
client_sock.close()
def thread_handler(self, client_sock, address):
size = 1024
data = ""
print("in handler")
while True:
transfer = client_sock.recv(size)
data = data + transfer.decode('utf-8')
if '\n' in transfer.decode('utf-8'):
break
req = parse_req(data)
resp = call_api(req, self.cache, self.persistent, self.lock)
client_sock.send(resp.encode('utf-8'))
self.cache.show()
client_sock.close()
def register_account():
"""
This method should add another user
:return: A notification of successful
"""
params = {'username': fields.String(), 'password': fields.String()}
json_data = parse_req(params)
try:
username = json_data.get('username', None)
password = json_data.get('password', None)
except:
return send_error(code=500)
query_account = {'username': username, 'password': password}
find_username = userRegister.find({}, {'username': 1, '_id': 0})
for user in find_username:
if user['username'] == username:
return jsonify("This account is already exist !")
try:
result = userRegister.insert_one(query_account)
return send_result(result)
except:
return send_error(code=500)
def run_server(self):
self.polling = PollingSocket(self.host, self.port)
self.init_helpers()
self.run_helpers()
#num_req = 0
#first = True
#tot_time = 0
while True:
requests = self.polling.poll_connection()
#start = time.time()
#num_req += len(requests)
#if num_req:
# if first:
# tot_time = 0
# first = False
# if tot_time >= 1:
# with open('ep.lg', 'a') as f:
# f.write(str(num_req)+" "+str(tot_time)+"\n")
# #print(str(num_req)+" "+str(tot_time)+"\n")
# num_req = 0
# tot_time = 0
for request in requests:
#Request is a tuple of sock, request_data
data = request[1]
#Process request here
req = parse_req(data.decode('utf-8'))
req.fd = request[0]
if req.op == 'GET':
val = self.cache.get(req.key)
if val is None:
# Cache miss: non-blocking put to req_queue
# for helper_threads to consume
self.issue_request(req)
else:
resp = val
add_response(self.polling.sock_data_map, request[0], resp)
elif req.op == 'PUT':
retval = self.cache.put(req.key, req.value)
if retval is None:
#Cache miss
self.issue_request(req)
else:
resp = "ACK"
add_response(self.polling.sock_data_map, request[0], resp)
elif req.op in ['INSERT', 'DELETE']:
self.issue_request(req)
else:
resp = "-1".encode('utf-8')
add_response(self.polling.sock_data_map, request[0], resp)
# Consume from response queue (non-blocking)
try:
responses = self.get_responses()
for resp in responses:
#Ignore for write-back requests
if resp.fd is None:
continue
#resp.value is actual value for GET
#for PUT/INSERT resp.value is "ACK" message
#resp.value is "-1" for all errors
#Delete needs special check if nothing to
#delete from both cache and persistent
if resp.op != 'DELETE':
add_response(self.polling.sock_data_map, resp.fd, resp.value)
#Entry brought to cache line for GET/PUT miss and INSERT
if resp.op in ['GET', 'PUT', 'INSERT']:
if resp.value != "-1":
self.__bring_to_cache(resp.key, resp.value, False)
elif resp.op == 'DELETE':
result = self.cache.delete(req.key)
if resp.value == "-1" and result is False:
#Nothing to delete from cache/ persistent
add_response(self.polling.sock_data_map, resp.fd, "-1")
else:
add_response(self.polling.sock_data_map, resp.fd, "ACK")
else:
pass
#self.cache.show()
except:
pass
