def setUp(self):
neo_config.load_config()
neo_config.set_project_variables()
neo = NeoAPI(neo_config)
self.api = neo.activate_testing()
self.user1 = db.session.query(UserModel).filter(
UserModel.email == "*****@*****.**").first()
if self.user1 is None:
self.user1 = UserModel(email="*****@*****.**",
password="******",
first_name="firstname",
last_name="lastname",
birthday="1995-12-12")
self.user2 = db.session.query(UserModel).filter(
UserModel.email == "*****@*****.**").first()
if self.user2 is None:
self.user2 = UserModel(email="*****@*****.**",
password="******",
first_name="firstname",
last_name="lastname",
birthday="1111-11-11")
self.circle = Circle(name="Mamie")
self.linkCircle = UserToCircle(user=self.user1, circle=self.circle)
self.linkCircle2 = UserToCircle(user=self.user2, circle=self.circle)
db.session.commit()
self.token1 = authenticate_user(self.api, self.user1, "test")
self.token2 = authenticate_user(self.api, self.user2, "test")
self.tokenAdmin = authenticate_user(self.api,
"*****@*****.**",
"PapieNeo2019")
def setUp(self):
neo_config.load_config()
neo_config.set_project_variables()
neo = NeoAPI(neo_config)
self.api = neo.activate_testing()
self.user1 = db.session.query(UserModel).filter(UserModel.email == "*****@*****.**").first()
if self.user1 is None:
self.user1 = UserModel(email="*****@*****.**", password="******", first_name="firstname",
last_name="lastname", birthday="1995-12-12")
self.user2 = db.session.query(UserModel).filter(UserModel.email == "*****@*****.**").first()
if self.user2 is None:
self.user2 = UserModel(email="*****@*****.**", password="******", first_name="firstname",
last_name="lastname", birthday="1111-11-11")
self.user3 = db.session.query(UserModel).filter(UserModel.email == "*****@*****.**").first()
if self.user3 is None:
self.user3 = UserModel(email="*****@*****.**", password="******", first_name="firstname",
last_name="lastname", birthday="1111-11-11")
self.create_circle()
self.conv1 = Conversation(name="ConversationInfoTest")
self.conv2 = Conversation(name="ConversationInfoTest2")
self.conv3 = Conversation(name="ConversationInfoTest2")
self.UserToConv1 = UserToConv()
self.UserToConv2 = UserToConv()
self.UserToConv3 = UserToConv()
self.UserToConv4 = UserToConv()
self.create_conversation(self.conv1, self.user1, self.user2, self.UserToConv1, self.UserToConv2, self.circle)
self.create_conversation(self.conv3, self.user1, self.user2, UserToConv(), UserToConv(), self.circle)
self.create_conversation(self.conv2, self.user2, self.user3, self.UserToConv3, self.UserToConv4, self.circle2)
self.token1 = authenticate_user(self.api, self.user1, "test")
self.token2 = authenticate_user(self.api, self.user2, "test")
self.token3 = authenticate_user(self.api, self.user3, "test")
self.tokenAdmin = authenticate_user(self.api, "*****@*****.**", "PapieNeo2019")
def post(self):
user = user_schema.load(request.get_json(), partial=True)
# prevent double account
if UserModel.find_by_id(user.id):
return {'message': 'Account already exists'}, 401
user.username = user.username.lower()
user.ip = request.remote_addr
# assign unique id
player_id = None
while player_id is None:
temp = UserModel.get_new_PlayerId()
if UserModel.find_by_playerId(temp) is None:
player_id = temp
# user creation
user.playerId = player_id
user.save_to_db()
# settings creation
settings = UserSettingsModel(user_id=user.id)
settings.save_to_db()
return
def post(cls, userId):
json_data = request.get_json()
user_data = UserModel.find_by_id(userId)
admin_data = UserModel.find_by_id(json_data['admin_id'])
user_devices = DeviceModel.find_my_devices(userId)
type(user_devices)
print(len(user_devices))
if user_data:
if len(user_devices) == 0:
if admin_data:
if admin_data.role == "admin":
if user_data.isActivated:
user_data.isActivated = False
user_data.insert_user()
return {"Message": "User is DeActivated"}, 201
return {"Message": "User is Already DeActivated"}, 401
return {
"Message":
"You dont have an access to deactivate other user"
}, 401
return {"Message": "Admin Not Found"}, 401
return {
"Message": "User has some devices so you cannot deactivate him"
}, 401
return {"Message": "User Not Found"}, 401
def setUp(self):
neo_config.load_config()
neo_config.set_project_variables()
neo = NeoAPI(neo_config)
self.api = neo.activate_testing()
self.user1 = db.session.query(UserModel).filter(
UserModel.email == "*****@*****.**").first()
if self.user1 is None:
self.user1 = UserModel(email="*****@*****.**",
password="******",
first_name="firstname",
last_name="lastname",
birthday="1995-12-12")
self.user2 = db.session.query(UserModel).filter(
UserModel.email == "*****@*****.**").first()
if self.user2 is None:
self.user2 = UserModel(email="*****@*****.**",
password="******",
first_name="firstname",
last_name="lastname",
birthday="1111-11-11")
self.create_circle("INFO1")
self.create_circle("INFO2")
self.create_circle("INFO3")
self.token1 = authenticate_user(self.api, self.user1, "test")
self.token2 = authenticate_user(self.api, self.user2, "test")
self.tokenAdmin = authenticate_user(self.api,
"*****@*****.**",
"PapieNeo2019")
def add_update_user():
if not LoginController.athenticate_user():
return redirect(url_for("google.login"))
resp = google.get("/oauth2/v2/userinfo")
email = resp.json()["email"]
message = "User created/updated successfully."
form = UserForm()
if form.validate_on_submit():
username = form.username.data
dept_id = form.dept_id.data
login_ip = form.login_ip.data
user = UserModel.find_by_username(username)
if user:
user.dept_id = dept_id
user.login_ip = login_ip
else:
user = UserModel(username, dept_id, login_ip)
try:
user.save()
except:
message = "Unable to save/update user"
flash(message)
return render_template('add_user.html', form=form, email=email)
def reset_post():
email = request.form.get('email')
pwd = request.form.get('password')
conf_pwd = request.form.get('conf_password')
if pwd != conf_pwd:
flash("Passwords don't math")
return redirect(url_for('auth.reset', email=email))
user = UserModel.get_one(args={'email': email, 'request_reset': True})
if not user:
flash("No such a user with email {} found".format(email))
return redirect(url_for('auth.login'))
hash_pwd = UserModel.generate_hash(pwd)
user.update(args={
'email': email,
'request_reset': True
},
data={
"$set": {
'password': hash_pwd
},
'$unset': {
'request_reset': 1,
'reset_code': 1
}
})
return redirect(url_for('auth.login'))
def setUp(self):
neo_config.load_config()
neo_config.set_project_variables()
neo = NeoAPI(neo_config)
self.api = neo.activate_testing()
self.user1 = db.session.query(UserModel).filter(
UserModel.email == "*****@*****.**").first()
if self.user1 is None:
self.user1 = UserModel(email="*****@*****.**",
password="******",
first_name="firstname",
last_name="lastname",
birthday="1995-12-12")
self.user2 = db.session.query(UserModel).filter(
UserModel.email == "*****@*****.**").first()
if self.user2 is None:
self.user2 = UserModel(email="*****@*****.**",
password="******",
first_name="firstname",
last_name="lastname",
birthday="1111-11-11")
self.circle1 = Circle(name="TestPaymentCircle")
self.link1 = UserToCircle()
self.link1.user = self.user1
self.link1.circle = self.circle1
db.session.commit()
self.token1 = authenticate_user(self.api, self.user1, "test")
self.token2 = authenticate_user(self.api, self.user2, "test")
def put(cls, reqId):
json_data = request.get_json()
request_data = RequestModel.find_by_id(reqId)
if request_data.reqStatus == "pending":
device_data = DeviceModel.find_by_id(request_data.deviceId)
user_data = UserModel.find_by_id(request_data.userId)
req_audit_obj = {"reqId": reqId, "handleBy": json_data["admin_id"]}
req_audit_model = RequestAuditModel(**req_audit_obj)
admin_data = UserModel.find_by_id(json_data['admin_id'])
if request_data and admin_data.role == "admin":
request_data.reqStatus = "declined"
device_data.status = "available"
device_data.assignTo = "0"
device_data.releaseDate = None
request_data.insert_request()
device_data.insert_device()
req_audit_model.insert_request_audit()
# declined request
return {"Message": "Request Declined Successfully"}, 201
return {"Message": "Request Not Found"}, 401
return {"Message": "Request Already Resolve"}, 403
def setUp(self):
neo_config.load_config()
neo_config.set_project_variables()
self.neo = NeoAPI(neo_config)
self.api = self.neo.activate_testing()
self.client = SocketIOTestClient(self.neo.app, socketio)
self.client.disconnect()
self.user1 = db.session.query(UserModel).filter(UserModel.email == "*****@*****.**").first()
if self.user1 is None:
self.user1 = UserModel(email="*****@*****.**", password="******", first_name="firstname",
last_name="lastname", birthday="1995-12-12")
self.user2 = db.session.query(UserModel).filter(UserModel.email == "*****@*****.**").first()
if self.user2 is None:
self.user2 = UserModel(email="*****@*****.**", password="******", first_name="firstname",
last_name="lastname", birthday="1995-12-12")
self.circle = Circle(name="Mamie")
self.linkCircle = UserToCircle(user=self.user1, circle=self.circle, privilege="ADMIN")
self.conversation = Conversation("test", device_access=True)
self.conversation.device_access = True
self.conversation.circle = self.circle
self.link2 = UserToConversation(user=self.user2, conversation=self.conversation)
self.device = Device(name="Papie")
self.device.circle = self.circle
self.device_password = self.device.get_pre_activation_password()
self.device.activate(self.device.key)
db.session.commit()
self.circle_id = self.circle.id
self.conversation_id = self.conversation.id
self.token1 = authenticate_user(self.api, self.user1, "test")
self.token2 = authenticate_user(self.api, self.user2, "test")
self.device_token = authenticate_device(self.api, self.device, self.device_password)
self.tokenAdmin = authenticate_user(self.api, "*****@*****.**", "PapieNeo2019")
def post(self):
data = UserRegister.parser.parse_args()
if UserModel.find_by_username(data['username']):
return {"massage": "this username already exist"}, 400
user = UserModel(**data)
user.save()
return {"massage": "user created successfully"}, 201
def put(cls, deviceId, userId):
json_data = request.get_json()
device_data = DeviceModel.find_by_id(deviceId)
if device_data.status == "blocked" or device_data.status == "allocated":
return {"Message": "Device is not available"}, 401
user_data = UserModel.find_by_id(userId)
req_obj = {"deviceId": deviceId, "userId": userId}
request_model = RequestModel(**req_obj)
device_obj = {
"deviceId": deviceId,
"userId": userId,
"allocateBy": json_data["admin_id"]
}
device_audit_model = DeviceAuditModel(**device_obj)
admin_data = UserModel.find_by_id(json_data['admin_id'])
if device_data and user_data and admin_data.role == "admin":
# if device_data.status == "created" or device_data.status == "available" :
if user_data.isActivated:
if device_data.isActivated:
# device_data.isAvailable = False
# if user_data.role == "admin":
request_model.reqStatus = "approved"
device_data.status = "allocated"
device_data.assignTo = user_data.email
device_data.releaseDate = json_data["releaseDate"]
try:
device_data.insert_device()
request_model.insert_request()
# return {"Message": "DEVICE ASSIGNED"}, 201
except:
return {"Message": "INTERNAL SERVER ERROR"}, 401
req_model = RequestModel.get_my_last_request(
deviceId, userId)
req_audit_obj = {
"reqId": req_model.reqId,
"handleBy": json_data["admin_id"]
}
req_audit_model = RequestAuditModel(**req_audit_obj)
# try:
req_audit_model.insert_request_audit()
device_audit_model.insert_device_audit()
return {"Message": "DEVICE ASSIGNED"}, 201
# except:
# return {"Message": "INTERNAL SERVER ERROR"}, 403
# return {"Message": "DEVICE ALREADY ASSIGNED TO USER"}, 403
return {"Message": "DEVICE IS NOT ACTIVATED TO ASSIGN"}, 400
return {"Message": "USER IS NOT ACTIVATED TO ASSIGN"}, 400
return {"MESSAGE": "INVALID REQUEST"}, 400
def post(self):
data = UserRegister.parser.parse_args()
if UserModel.find_by_username(data['username']):
return {'message': 'username already exists'}, 400
user = UserModel(**data)
user.save_to_db()
return {'message': 'User created successfully '}, 201
def post(self):
data = UserRegister.parser.parse_args()
if UserModel.find_by_username(data['username']):
return {"message": "User with that username already exists."}, 400
user = UserModel(**data)
user.save_to_db()
return {"message": "User created successfully."}, 201
def post(self):
data = Register.parser.parse_args()
reguser = UserModel(data['username'], data['password'])
try:
UserModel.save_to_db(reguser)
return {"messege": "User registered successfully!"}
except:
return {"messege": "An error occurred registering user!"}
def get(self, _id=None):
if _id:
user = UserModel.find_by_id(_id)
if user:
return BaseResponse.ok_response('Successful.',
user.json(is_long=True))
return BaseResponse.bad_request_response('User does not exists.',
{})
else:
users = list(
map(lambda x: x.json(is_long=True), UserModel.find_all()))
return BaseResponse.ok_response('Successful.', users)
def setUp(self):
neo_config.load_config()
neo_config.set_project_variables()
neo = NeoAPI(neo_config)
self.api = neo.activate_testing()
self.user1 = db.session.query(UserModel).filter(
UserModel.email == "*****@*****.**").first()
if self.user1 is None:
self.user1 = UserModel(email="*****@*****.**",
password="******",
first_name="firstname",
last_name="lastname",
birthday="1995-12-12")
self.user2 = db.session.query(UserModel).filter(
UserModel.email == "*****@*****.**").first()
if self.user2 is None:
self.user2 = UserModel(email="*****@*****.**",
password="******",
first_name="firstname",
last_name="lastname",
birthday="1111-11-11")
self.circle = Circle(name="Mamie")
self.circle2 = Circle(name="test")
self.linkCircle = UserToCircle(user=self.user1,
circle=self.circle,
privilege="ADMIN")
self.linkCircle2 = UserToCircle(user=self.user2, circle=self.circle)
self.conversation = Conversation("test")
self.conversation.circle = self.circle
self.conversation.device_access = True
self.device = Device(name="Papie")
self.device2 = Device(name="test")
self.device2.circle = self.circle2
self.device2_password = self.device2.get_pre_activation_password()
self.device2.activate(self.device2.key)
self.device.circle = self.circle
self.device_password = self.device.get_pre_activation_password()
self.device.activate(self.device.key)
self.message = Message(is_user=False)
self.message.conversation = self.conversation
self.message.device = self.device
db.session.commit()
self.token1 = authenticate_user(self.api, self.user1, "test")
self.token2 = authenticate_user(self.api, self.user2, "test")
self.device_token = authenticate_device(self.api, self.device,
self.device_password)
self.device2_token = authenticate_device(self.api, self.device2,
self.device2_password)
self.tokenAdmin = authenticate_user(self.api,
"*****@*****.**",
"PapieNeo2019")
def post(cls):
json_data = request.get_json()
print(type(json_data))
user = UserModel.find_by_email(json_data['email'])
if user:
return {"Message": "User with this email is already register"}, 401
# personal_info = {
# "username" : json_data["username"],
# "password" : json_data["password"],
# "email" : json_data["email"],
# "role": json_data["role"],
# "firstName": json_data["firstName"],
# "lastName": json_data["lastName"]
# }
try:
user_data = UserSchema().load(json_data)
print(user_data)
except ValidationError as err:
return err.messages, 401
try:
user_model = UserModel(**user_data)
if user_model.role == "admin":
user_model.isActivated = True
user_model.insert_user()
else:
user_model.insert_user()
except:
return {"Message": "USER_INSERTION_ERROR"}, 401
return {"Message": "USER_REGISTRATION_SUCCESSFUL"}, 201
def setUp(self):
neo_config.load_config()
neo_config.set_project_variables()
neo = NeoAPI(neo_config)
self.api = neo.activate_testing()
self.user1 = db.session.query(UserModel).filter(
UserModel.email == "*****@*****.**").first()
if self.user1 is None:
self.user1 = UserModel(email="*****@*****.**",
password="******",
first_name="firstname",
last_name="lastname",
birthday="1995-12-12")
self.user2 = db.session.query(UserModel).filter(
UserModel.email == "*****@*****.**").first()
if self.user2 is None:
self.user2 = UserModel(email="*****@*****.**",
password="******",
first_name="firstname",
last_name="lastname",
birthday="1111-11-11")
self.user3 = db.session.query(UserModel).filter(
UserModel.email == "*****@*****.**").first()
if self.user3 is None:
self.user3 = UserModel(email="*****@*****.**",
password="******",
first_name="firstname",
last_name="lastname",
birthday="1111-11-11")
self.circle = Circle(name="TestConversationinvite")
self.link = UserToCircle()
self.link.user = self.user1
self.link.circle = self.circle
self.link2 = UserToCircle()
self.link2.user = self.user2
self.link2.circle = self.circle
self.conv = Conversation()
self.conv.circle = self.circle
self.utc1 = UserToConversation(privilege="ADMIN")
self.utc1.user = self.user1
self.utc1.conversation = self.conv
self.utc2 = UserToConversation(privilege="STANDARD")
self.utc2.user = self.user2
self.utc2.conversation = self.conv
db.session.commit()
self.token1 = authenticate_user(self.api, self.user1, "test")
self.token2 = authenticate_user(self.api, self.user2, "test")
self.token3 = authenticate_user(self.api, self.user3, "test")
def delete(cls, user_id):
user = UserModel.find_by_id(user_id)
if not user:
return {"message": "User does not exit"}, 404
else:
return user.delete_from_db()
def forget_post():
email = request.form.get('email')
user = UserModel.get_one(args={'email': email})
if not user:
flash("Please check your login details and try again")
return redirect(url_for('auth.login'))
reset_code = os.urandom(5).hex()
user.update(
args={'email': email},
data={"$set": {
'request_reset': True,
'reset_code': reset_code
}})
# send reset password email
html = render_template("emails/reset-password.html",
email=email,
server=server,
code=reset_code)
send_email(subject="Reset Password", html=html, user_email=email)
flash(
"A reset link has been sent to your email, kindly check and reset your password"
)
return redirect(url_for('auth.login'))
def delete(cls):
try:
user_id = get_jwt_identity()
data = user_anime_save_schema.load(request.get_json())
user = UserModel.find_by_username(user_id)
anime_id = data['anime_id']
if user:
if user.has_user_saved_anime(anime_id):
successful = user.remove_anime(anime_id)
if successful:
return {
"message": get_text('user_anime_removing_successful')
}, 200
return {
"message": get_text('user_anime_removing_error')
}, 400
return {
"message": get_text('user_anime_not_saved_before')
}, 404
return {
"message": get_text('user_not_found')
}, 404
except ValidationError as error:
return {"message": get_text('input_error_generic'), "info": error.messages}, 400
except Exception as ex:
print(ex)
return {"message": get_text('server_error_generic')}, 500
def get(cls):
username = get_jwt_identity()
try:
user = UserModel.find_by_username(username)
if user:
saved_animes = user.saved_animes.\
with_entities("anime_info.anime_id", "anime_info.title", "anime_info.poster_uri").\
order_by("title").all()
return {
**user_min_info_schema.dump(user),
"saved_animes": [
{
"title": saved_anime[1],
"anime_id": str(saved_anime[0]),
"poster_uri": saved_anime[2]
} for saved_anime in saved_animes
]
}, 200
return {
"message": get_text('user_not_found')
}, 404
except Exception as ex:
print(ex)
return {"message": get_text('server_error_generic')}, 500
def post(cls):
json_data = request.get_json()
user = UserModel.find_by_id(json_data["userId"])
device = DeviceModel.find_by_id(json_data["deviceId"])
print(json_data["releaseDate"])
if device.status == "available" or device.status == "created":
if user and device:
if device.isActivated:
if device.status == "created" or device.status == "available":
try:
req_obj = {
"deviceId": json_data["deviceId"],
"userId": json_data["userId"]
}
request_data = request_schema.load(req_obj)
except ValidationError as err:
return err.messages, 401
try:
request_model = RequestModel(**request_data)
device.status = "blocked"
device.releaseDate = json_data["releaseDate"]
request_model.insert_request()
device.insert_device()
except:
return {"Message": "REQUEST INSERT ERROR"}, 401
return {"Message": "REQUEST SUCCESSFULLY ADDED"}, 201
return {"Message": "DEVICE IS NOT AVAILABLE"}, 401
return {"Message": "DEVICE IS NOT ACTIVATED"}, 401
return {"Message": "SOMETHING GETTING WRONG"}, 401
return {"Messgae": "Device is not available to request"}, 401
def reset(email, code):
user = UserModel.get_one(args={'email': email, 'request_reset': True})
if user and user.request_reset:
if user.reset_code == code:
return render_template("reset.html", email=email)
flash("Reset password link is expired")
return redirect(url_for('auth.login'))
def verify_account(email, code):
user = UserModel.get_one(args={"email": email})
if user:
_user = user.to_json()
if bool(_user.get('verification_code', "")):
if user.verification_code == code:
user.update(args={"email": email},
data={
'$set': {
'is_authenticated': True,
'is_active': True
},
'$unset': {
'verification_code': 1
}
})
return redirect(url_for('auth.login'))
flash("Oh! wrong verification code!")
return redirect(url_for('auth.login'))
flash("You're account had been already verified!")
return redirect(url_for('auth.login'))
flash("No such a user with email {} found!".format(email))
return redirect(url_for('auth.login'))
def get(cls, anime_id):
if not valid_uuid4(anime_id):
response = {"message": get_text('anime_uuid_error')}
return response, 400
anime = AnimeModel.find_by_id(anime_id)
username = get_jwt_identity()
anime_bookmarked = False
if username: # if there is an authenticated user
# get the user and check if he saved the anime
user = UserModel.find_by_username(username)
if user.has_user_saved_anime(anime_id):
anime_bookmarked = True
if anime:
episodes = anime.\
episodes.\
with_entities("episode_id", "episode_number").\
order_by("episode_number").all()
anime_data = {
**anime_info_schema.dump(anime), "anime_bookmarked":
anime_bookmarked,
"episodes": episode_schema.dump(episodes)
}
return anime_data, 200
return {
"message": get_text('anime_not_found').format(anime_id=anime_id)
}, 404
def delete(self, _id: str):
user = UserModel.find_by_id(_id)
if user:
user.delete_from_db()
return {'message': 'Account deleted'}, 200
return {'message': 'Account not found'}, 404
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)
user.save_to_db()
# connection = sqlite3.connect("data.db")
# cursor = connection.cursor()
# query = "INSERT INTO users VALUES (NULL,?,?)"
# cursor.execute(query, (data["username"], data["password"]))
# connection.commit()
# connection.close()
return {"message": "User created successfuly."}, 201
def post(self):
data = _user_parser.parse_args()
if UserModel.find_by_username(data['username']):
return {"message": "A user with that username already exists"}, 400
elif len(data['username']) < 4:
return {
"message": "Username must have more than 3 characters"
}, 400
elif len(data['password']) < 8:
return {
"message": "Password must have more than 7 characters"
}, 400
user = UserModel(**data)
user.save_to_db()
return {"message": "User created successfully."}, 201
