def __init__(self, db:SQLDB):
self.user_model = UserModel(db)
self.role_model = RoleModel(db)
self.action_model = ActionTypeModel(db)
self.resource_model = ResourceModel(db)
self.policy_model = PolicyModel(db)
def login():
if not request.is_json:
return jsonify({"Message": "Missing JSON in request"}), 400
username = request.json.get('username', None)
password = request.json.get('password', None)
if not username:
return jsonify({"Message": "Missing username parameter"}), 400
if not password:
return jsonify({"Message": "Missing password parameter"}), 400
# See if there is a user with this particular username
if UserModel.find_by_username(username) is not None:
user = UserModel.find_by_username(username)
else:
return jsonify(
{"Message": "No user with username {}".format(username)}), 404
if password == user.password:
access_token = create_access_token(identity=username)
returnJSON = {}
returnJSON["user"] = user.json()
returnJSON["access_token"] = access_token
else:
return jsonify({"Message": "Invalid Password"}), 400
return jsonify(returnJSON), 200
def patch(self):
parser = reqparse.RequestParser()
parser.add_argument("username",
type=str,
required=True,
help="Required Field"),
parser.add_argument("email",
type=str,
required=True,
help="Required Field"),
parser.add_argument("password",
type=str,
required=True,
help="Required Field")
data = parser.parse_args()
user_model = UserModel(data["username"].lower(), data["email"],
data["password"])
result = user_model.login_user()
if result == True:
access_token = create_access_token(identity=user_model.username)
refresh_token = create_refresh_token(identity=user_model.username)
return {
"message": "Success",
"access_token": access_token,
"refresh_token": refresh_token
}
else:
return {"message": "Unable to login user"}
def finished_round():
user = User(session['email'])
user_model = UserModel()
word_list_view = user_model.get_word_list_view(user)
seen_list = word_list_view.seen_word_list
learnt_list = word_list_view.learnt_word_list
forgotten_list = word_list_view.forgotten_word_list
# graph_pygal = pygal.Line()
# graph_pygal.title = '% Change Coolness of programming languages over time.'
# graph_pygal.x_labels = ['2011', '2012', '2013', '2014', '2015', '2016']
# graph_pygal.add('Python', [15, 31, 89, 200, 356, 900])
# graph_pygal.add('Java', [15, 45, 76, 80, 91, 95])
# graph_pygal.add('C++', [5, 51, 54, 102, 150, 201])
# graph_pygal.add('All others combined!', [5, 15, 21, 55, 92, 105])
pie_chart = pygal.Pie()
pie_chart.title = 'TITLE'
pie_chart.add('Seen Words', WordModel.get_number_labels(seen_list))
pie_chart.add('Forgotten Words', WordModel.get_number_labels(forgotten_list))
pie_chart.add('Learnt Words', WordModel.get_number_labels(learnt_list))
pie_chart.render()
graph_data = pie_chart.render_data_uri()
return render_template('list.html',
seen_list=seen_list,
learnt_list=learnt_list,
forgotten_list=forgotten_list,
graph_data=graph_data
)
def get(self, id):
user = UserModel.find_by_id(id)
if not user:
return {
"Message": "No user could be found with that ID"
}, 200, {
"Access-Control-Allow-Origin": "*"
}
current_user = get_jwt_identity()
currentUser = UserModel.find_by_username(current_user)
if user.id == currentUser.id or currentUser.role == 0:
if (user):
return user.json(), 200, {"Access-Control-Allow-Origin": "*"}
else:
return {
"Message":
"You cannot view information about other users unless you are a super admin."
}, 401, {
"Access-Control-Allow-Origin": "*"
}
return {
"Message": "No user could be found with that ID"
}, 200, {
"Access-Control-Allow-Origin": "*"
}
def post(cls):
data = cls.parser.parse_args()
target_user = UserModel.find_by_username(data["target_username"])
user_id = get_jwt_identity()
user = UserModel.find_by_id(user_id)
try:
if ConversationModel.find_by_target_user(user_id, target_user.id):
raise ConversationExists(user_id, target_user.id)
conversation = ConversationModel()
except ConversationExists as error:
return {"msg": "Duplicate entry. Error: {}".format(error)}, 409
try:
conversation.upsert(user, target_user)
except AttributeError as error:
return {
"msg":
"Target user does not exist in the database. Error: {}".format(
error)
}, 404
except DatabaseError as error:
return {
"msg":
"An error occurred while creating a new chat in the database. Error: {}"
.format(error)
}, 500
conversation_id = ConversationModel.find_by_target_user(
user_id, target_user.id)
join_room(conversation_id)
return {
"username": target_user.username,
"conversation_id": conversation_id
}, 201
def post(self):
# Acquire all of the data in a dict of each argument defined in the parser above.
data = DinnerRegistrar.parser.parse_args()
if ProfessorModel.find_by_id(data["professorID"]) is None:
return {
"Message":
"Dinner could not be created as no such professor could be found with id {}."
.format(data["professorID"])
}, 404, {
"Access-Control-Allow-Origin": "*"
}
if data["userID"]:
if data["userID"] == -1:
# Create a new ProfessorModel object containing the passed properties.
newDinner = DinnerModel(**(
data.pop("userID")
)) ## ** automatically separates dict keywords into arguments
# Iterate the amount of dinners for this professor by one
associatedProfessor = ProfessorModel.find_by_id(
data["professorID"])
associatedProfessor.dinnerCount += 1
associatedProfessor.save_to_db()
# Save the new professor to the database.
newDinner.save_to_db()
return newDinner.json(), 201, {
"Access-Control-Allow-Origin": "*"
}
elif not UserModel.find_by_id(data["userID"]):
return {
"Message":
"There is no user in the database with that ID. Could not create dinner"
}, 404, {
"Access-Control-Allow-Origin": "*"
}
else:
user = UserModel.find_by_id(data["userID"])
user.dinnerCount += 1
user.semDinnerCount += 1
user.save_to_db()
# Create a new ProfessorModel object containing the passed properties.
newDinner = DinnerModel(
**data) ## ** automatically separates dict keywords into arguments
# Iterate the amount of dinners for this professor by one
associatedProfessor = ProfessorModel.find_by_id(data["professorID"])
associatedProfessor.dinnerCount += 1
associatedProfessor.save_to_db()
# Save the new professor to the database.
newDinner.save_to_db()
return newDinner.json(), 201, {"Access-Control-Allow-Origin": "*"}
def post(self, username):
data = User.parser.parse_args()
user = UserModel.find_by_username(data['username'])
if user:
return {"message": "username already exist"}
user = UserModel(**data)
user.insert_in_db()
return {"message": "success"}
def on_connect():
if not decode_token(request.cookies['access_token_cookie']):
raise ConnectionRefusedError('incorrect token')
user_id = get_jwt_identity()
user = UserModel.find_by_id(user_id)
UserModel.add_current_user(user.username)
online_users = UserModel.get_current_users()
emit('get_users', online_users, broadcast=True)
def post(self):
dados = atributos.parse_args()
if UserModel.find_by_login(dados['login']):
return {'message':"The login '{}' alredy exists" .format(dados['login'])}
user = UserModel(**dados)
user.save_user()
return {'message': "User created successfully"},201
def post(self):
data = UserRegister.parser.parse_args()
if UserModel.findByUsername(data['username']):
return {'message': "User already exists"}, 400
user = UserModel(**data)
user.save_to_db()
return {"message": "User created successfully"}
def post(self):
data = UserRegister.parser.parse_args()
if UserModel.find_by_username(data['username']):
return {"message": "A user with that username already exists"}, 400
user = UserModel(data['username'], data['password'])
user.save_to_db()
return {"message": "User created successfully."}, 201
def post(self, username):
data = UserResource.parser.parse_args()
user = UserModel.find_by_username(username)
if user:
return {"registration": "exists"}, 201
else:
user = UserModel(**data)
user.save_to_db()
subject = "No-Reply: ExpenseHandler - Account creation successful."
keyWord = "register"
MailService.sendEmail(data["emailId"], subject, data["firstname"], keyWord, data["password"])
return {"registration": "success"}, 201
def put(self):
data = post_parser.parse_args()
if UserModel.find_by_name(data.username) is None:
raise ResourceDoesNotExistError(
"username '{}' not exist!".format(username))
user = UserModel(**data)
if user.update_user() is None:
raise InternelServerError(
"An error occurred update_user the item. '{}'".format(
data.username))
return Common.returnTrueJson(Common, marshal(user, user_fields))
def get(self):
current_user = get_jwt_identity()
user = UserModel.find_by_username(current_user)
if user.role is not 0:
return {
"Message":
"Only super admins may access the list of all users. You lack permissions."
}, 401
return UserModel.return_all(), 200, {
"Access-Control-Allow-Origin": "*"
}
def post(self):
data = post_parser.parse_args()
if UserModel.find_by_name(data.username):
raise AlreadyExistsError(
"An item with name '{}' already exists.".format(data.username))
user = UserModel(**data)
if user.create_user() is None:
raise InternelServerError(
"An error occurred inserting the item. '{}'".format(
data.username))
return Common.returnTrueJson(Common, marshal(user, user_fields))
def post(self):
data = parser.parse_args()
if UserModel.find_by_username(data['username']):
return {
'Error': '{} user alredy exist'.format(data['username'])
}, 500
user = UserModel(username=data['username'],
password=Crypto.generate_hash(data['password']))
try:
user.save_to_db()
return create_token(data['username']), 200
except:
return {'message': 'Something went wrong'}, 500
def put(cls):
_parser_id = IdRequest(reqparse.RequestParser(bundle_errors=True))
_parser_id = _parser_id.validate()
_parser_register = UserRequest(reqparse.RequestParser())
_parser_register = _parser_register.validate()
_id = _parser_id.parse_args()['id']
data = _parser_register.parse_args()
user = UserModel.find_by_id(_id=_id)
if not user:
return {'message': message['not-found']}, 404
elif UserModel.find_by_username(_username=data['username'],
_method_update=True,
_id=_id):
return {"message": message['username-exist']}, 400
elif UserModel.find_by_email(_email=data['email'],
_method_update=True,
_id=_id):
return {"message": message['email-exist']}, 400
elif UserModel.find_by_phonenumber(_phonenumber=data['phonenumber'],
_method_update=True,
_id=_id):
return {"message": message['phonenumber-exist']}, 400
user.name = data['name']
user.username = data['username']
user.photo_profile = data['photo_profile']
user.phonenumber = data['phonenumber']
user.birthday_place = data['birthday_place']
user.birthday = data['birthday']
user.address = data['address']
user.resume = data['resume']
user.headline = data['headline']
user.summary = data['summary']
user.email = data['email']
user.link_instagram = data['link_instagram']
user.link_linkedin = data['link_linkedin']
user.link_twitter = data['link_twitter']
user.link_youtube = data['link_youtube']
user.link_google_plus = data['link_google_plus']
user.link_facebook = data['link_facebook']
user.type_theme = data['type_theme']
if data['password'] or data['password'] != "":
user.password = helper.password_hash(data['password'])
user.update()
return {'message': message['updated'], 'data': user.json()}, 200
def post(cls):
data = cls.parser.parse_args()
user = UserModel(**data)
try:
user.upsert()
except DatabaseError as error:
return {
"msg":
"An error occurred while saving new user to database. Error: {}"
.format(error)
}, 500
return user.to_json(), 201
def test_update_user_with_all_fields():
# Create user
responce = RestApi.post(resource=CallNames.CREATE_USER_PATH,
payload=UserModel())
assert get_status_code(responce) == ApiKeyNames.CREATED_STATUS_CODE
user_id = get_user_id(responce)
# Update user
responce = RestApi.put(resource=CallNames.UPDATE_USER_PATH + str(user_id),
payload=UserModel())
assert get_status_code(responce) == ApiKeyNames.OK_STATUS_CODE
# Check updated data
assert get_user_name(responce) == UserModel().name
assert get_user_email(responce) == UserModel().email
assert get_user_gender(responce) == UserModel().gender
def post(cls):
_parser_register = UserRequest(
reqparse.RequestParser(bundle_errors=True))
_parser_register = _parser_register.validate()
data = _parser_register.parse_args()
if UserModel.find_by_username(_username=data['username']):
return {"message": message['username-exist']}, 400
elif UserModel.find_by_email(_email=data['email']):
return {"message": message['email-exist']}, 400
elif UserModel.find_by_phonenumber(_phonenumber=data['phonenumber']):
return {"message": message['phonenumber-exist']}, 400
user = UserModel(data['name'], data['username'], data['photo_profile'],
data['phonenumber'], data['birthday_place'],
data['birthday'], data['address'], data['resume'],
data['headline'], data['summary'], data['email'],
data['link_instagram'], data['link_linkedin'],
data['link_twitter'], data['link_youtube'],
data['link_google_plus'], data['link_facebook'],
data['password'], data['type_theme'])
user.save()
return {'message': message['inserted'], 'data': user.json()}, 201
def createSuperAdmin():
a = UserModel("unclaimed", "pass", "*****@*****.**", 0, "uncl10",
"12345", "Unclaimed", "User", "123-123-1234", 1,
"Lorem Ipsum")
b = UserModel("superadmin", "pass", "*****@*****.**", 0, "ce10",
"12345", "Super", "Admin", "123-123-1234", 1, "Lorem Ipsum")
db.session.add(a)
db.session.add(b)
db.session.commit()
allUsers = db.session.query(UserModel).all()
for user in allUsers:
print("ADMINS: {} {} ROLE: {}".format(user.firstName, user.lastName,
user.role))
def post(self):
data = UserRegister.parser.parse_args()
# check if username already exists
if UserModel.find_by_username(username=data['username']):
return {
'messagio': 'ALREADU EXOSTS !'
}, 400 # 201 - response code - created
user = UserModel(**data) # unpacking with **
user.save_to_db()
return {
'messagio': 'User was created succesfuly !'
}, 201 # 201 - response code - created
def on_send_chat(chat):
message = MessageModel(**chat)
user_id = get_jwt_identity()
user = UserModel.find_by_id(user_id)
conversation_list = ConversationModel.find_all_by_id(
message.conversation_id)
conversation_result = next(
filter(lambda conv: conv.user_id == user_id, conversation_list),
None)
conversation = ConversationModel.get_conversation(
conversation_result.conversation_id)
try:
message.upsert(user, conversation)
except DatabaseError as error:
return {
"msg":
"An error occurred while saving message to database. Error: {}"
.format(error)
}, 500
emit('receive_message',
message.to_json(),
room=message.conversation_id)
def get(self, username):
user = UserModel.find_by_name(username)
if user:
return Common.returnTrueJson(Common, marshal(user, user_fields))
raise ResourceDoesNotExistError(
"username '{}' not exist!".format(username))
def get_next_word():
if 'logged_in' in session:
logged_user = User(email=session['logged_in'])
word_view_list = UserModel().get_recommended_model_list(logged_user)
else:
word_view_list = UserModel().get_recommended_model_list()
words = [word.word for word in word_view_list]
t_twitter = threading.Thread(target=ExampleTwitterModel.trigger_database, args=(words, 0, 5))
t_wikipedia = threading.Thread(target=ExampleWikipediaModel.trigger_database, args=(words, 0, 2))
t_twitter.start()
t_wikipedia.start()
model_list = [word_model.get_dictionary() for word_model in word_view_list]
return parse_json(model_list)
def decorated_auth(*args, **kwargs):
if 'api-token' not in request.headers:
return Response(
mimetype="application/json",
response=json.dumps({
'error':
'Authentication token is not available, please login to get one'
}),
status=400)
token = request.headers.get('api-token')
data = Auth.decode_token(token)
if data['error']:
return Response(mimetype="application/json",
response=json.dumps(data['error']),
status=400)
user_id = data['data']['user_id']
check_user = UserModel.get_one_user(user_id)
if not check_user:
return Response(mimetype="application/json",
response=json.dumps({
'error':
'user does not exist, invalid token'
}),
status=400)
g.user = {'id': user_id}
return func(*args, **kwargs)
def json(self):
applicationJSON = [app.json() for app in self.applications]
studentReviewJSON = [
studentReview.json() for studentReview in self.studentReviews
]
if UserModel.find_by_id(self.userID):
userString = self.user.infojson()
else:
userString = "No User Selected"
return {
"id": self.id,
"timeStamp": self.timeStamp,
"topic": self.topic,
"description": self.description,
"studentLimit": self.studentLimit,
"address": self.address,
"dietaryRestrictions": self.dietaryRestrictions,
"status": self.status,
"invitationSentTimeStamp": self.invitationSentTimeStamp,
"catering": self.catering,
"transportation": self.transportation,
"professorID": self.professorID,
"professor": self.professor.json(),
"userID": self.userID,
"user": userString,
"applications": applicationJSON,
"studentReviews": studentReviewJSON
}
def load_template(self):
options = QFileDialog.Options()
options |= QFileDialog.DontUseNativeDialog
files, _ = QFileDialog.getOpenFileNames(
self,
"QFileDialog.getOpenFileNames()",
"",
"Json Files (*.json)",
options=options)
# TODO:Load template
if len(files) > 0:
with open(files[0], 'r') as f:
json_data = f.read()
data = json.loads(json_data)
if data['translation'] is not None:
self.translation_model = TranslationModel(
**data['translation'])
self.lblTranslation.setStyleSheet("color : green;")
self.lblTranslation.setText("OK")
if data['user'] is not None:
self.user_model = UserModel(**data['user'])
self.lblUser.setStyleSheet("color : green;")
self.lblUser.setText("OK")
else:
QMessageBox.about(self, 'Error message', 'Files was not selected')
def get():
user_id = get_jwt_identity()
user = UserModel.find_by_id(user_id)
return {
"username": user.username,
"id": user_id,
"email": user.email
}, 200
