def post(self):
json_data = request.get_json()
if not json_data:
return {'message': 'No input data provided'},400
try:
data = userLogSchema.load(json_data).data
except ValidationError as err:
return err.messages,400
try:
current_user = UserModel.find_by_user(data['username'])
except KeyError:
return {'message':'Sorry no username has been provided'},400
if not current_user:
return {'message': 'User {} doesn\'t exist'.format(data['username'])},400
if current_user.status == 'inactive':
return {'message': 'Your account has not been activated by the admin, please talk to your manager'},400
try:
logged_user = LoggedModel.find_by_user_businessid(current_user.username, current_user.businessId)
except Exception as err:
print(err)
if logged_user:
if current_user.username == logged_user.username:
return {'message':'You are already logged in, only one session allowed per user'}, 400
if UserModel.verify_hash(data['password'],current_user.password):
access_token = create_access_token(identity = data['username'])
refresh_token = create_refresh_token(identity = data['username'])
login_user = LoggedModel(
ztime = datetime.datetime.now(),
zutime = datetime.datetime.now(),
username = current_user.username,
businessId = current_user.businessId,
access_token = access_token,
refresh_token = refresh_token,
status = 'Logged In'
)
try:
login_user.save_to_db()
except Exception as err:
return {'message':'Error # 171 could not save to logged user'}
return {
'message': 'Logged in as {}'.format(current_user.username),
'access_token': access_token,
'refresh_token': refresh_token,
'businessId': current_user.businessId,
'employeeCode' : current_user.employeeCode,
'userRole': current_user.is_admin,
'employee_name':current_user.employee_name
},200
else:
return {'message': 'Wrong credentials'},400
def post(self, user_id):
data = request.get_json()
blocchi = int(data["blocchi"])
corsie = int(data["corsie"])
livelli = int(data["livelli"])
if blocchi > corsie:
return "troppi blocchi", 406
user = UserModel.find_by_id(user_id)
lobby = LobbyModel.find_by_id(user.lobby_id)
if lobby.status == 1:
return "match has already started", 403
# RANDOM POSITION
user.give_random_corsia(lobby.corsie)
lobby.status = 1
users = UserModel.find_all_by_lobby_id_and_status(lobby.id, 1)
for u in users:
u.status = 2
u.jolly_earthquake = 1
u.jolly_reveal = 1
u.save_to_db()
n_users = UserModel.find_all_by_lobby_id_and_status(lobby.id, 0)
for u in n_users:
u.jolly_earthquake = 0
u.jolly_reveal = 0
u.pedina_number = 0
u.save_to_db()
lobby.update_turn()
lobby.blocchi = blocchi
lobby.livelli = livelli
lobby.corsie = corsie
lobby.save_to_db()
lobby.create_blocks()
return "match started", 200
def post(self):
data = parser.parse_args()
username = data['username']
# Searching user by username
current_user = UserModel.find_by_username(username)
# user does not exists
if not current_user:
return jsonify({'message': f'User {username} doesn\'t exist'})
# user exists, comparing password and hash
if UserModel.verify_hash(data['password'], current_user.password):
# generating access token and refresh token
access_token = create_access_token(
identity=username, expires_delta=timedelta(hours=2))
refresh_token = create_refresh_token(identity=username)
return jsonify({
'message': f'Logged in as {username}',
'access_token': access_token,
'refresh_token': refresh_token
})
else:
return jsonify({'message': "Wrong credentials"})
def register():
newUser = request.get_json()
if UserModel.find_by_username(newUser['username']):
return {'message':'Username already exists'}, 400
user = UserModel(newUser['username'],hash_password(newUser['password']))
user.save_to_db()
return jsonify({'message':'User created successfully'})
def post():
user = UserRegisterResource.parser.parse_args()
if UserModel.find_by_username(user.username):
abort(409, message="User Already Exists")
new_user = UserModel(**user)
new_user.add_user()
return {'message': f"added {new_user.username}"}, 201
def put(self):
data = UserRegister.parser.parse_args()
msg = ''
if data['username']:
user = UserModel.find_user_details(data['username'])
if user:
if data['password']: user.password = data['password']
#if data['group'] :
user.access = data['group']
else:
user = UserModel(**data)
try:
user.save_to_db()
except:
return {'message': "Please recheck the entries."}, 400
msg += "User has been created/updated."
if data['code']:
priv = AccessModel.get_priviledges(data['group'])
if priv:
priv.access_granted = data['code']
else:
priv = AccessModel(data['group'], data['code'])
try:
priv.add_to_db()
except:
return {
'message': "Please check 'group' or 'code' value."
}, 400
msg += "Group has been created/updated."
return {"message": msg}, 200
def post(self):
lobby = LobbyModel()
lobby.save_to_db()
user = UserModel(lobby_id=lobby.id)
user.save_to_db()
LobbyModel.erase_unused()
return [lobby.tag, user.id]
def post(self, lobby_tag):
lobby = LobbyModel.find_by_tag(lobby_tag)
if not lobby:
return "bleah", 432
user = UserModel(lobby_id=lobby.id)
user.save_to_db()
return user.id
def post(self):
try:
data = api.payload
username = data['username']
email = data['email']
password = data['password']
if UserModel.check_email_exist(email):
return {"status": "Email already exists"}, 400
else:
hashed_password = generate_password_hash(password)
user = UserModel(username=username,
email=email,
password=hashed_password)
user.create_record()
return {"status": "User added successfully"}, 201
except KeyError as e:
api.abort(500,
e.__doc__,
status="Could not perform this action",
statusCode="500")
except KeyError as e:
api.abort(400,
e.__doc__,
status="Could not perform this action",
statusCode="400")
def post(self):
# post a user using valid credentials
try:
data = api.payload
email = data['email']
password = data['password']
# checks if the email exists
if UserModel.check_email_exist(email):
# checks if the password is valid
if UserModel.check_password(email, password):
return {'status': 'User successfully logged in'}, 200
else:
return {'status': 'Wrong login credentials!'}, 401
else:
return {'status': 'Email does not exist!'}, 401
except KeyError as e:
api.abort(500,
e.__doc__,
status="Could not perform this action",
statusCode="500")
except KeyError as e:
api.abort(400,
e.__doc__,
status="Could not perform this action",
statusCode="400")
def post(self):
mail=request.args.get('mail')
username=request.args.get('username')
password=request.args.get('password')
phone=request.args.get('phoneNumber')
user=UserModel.find_by_mail(mail)
if user:
if user.confirmed==True:
return "mail already taken", 413
epsw=password.encode('utf-8')
hashed_password = hashlib.sha512(epsw).hexdigest()
user.username=username
user.password=hashed_password
user.phone_number=phone
user.creation_date=time.time()
user.password_change=time.time()
user.save_to_db()
else:
now = time.time()
epsw=password.encode('utf-8')
hashed_password = hashlib.sha512(epsw).hexdigest()
user=UserModel(mail, phone, username, hashed_password)
user.save_to_db()
return user.username
sendmail(mail, username)
return "user created, to be confirmed", 200
def post(self):
user = UserRegisterResource.parser.parse_args()
if UserModel.find_by_username(user.username):
return {'message': 'user already exists'}, 409
user = UserModel(**user)
user.add_user()
return {'message': 'user added'}, 201
def post(self):
user_data = UserRegister.parser.parse_args()
if UserModel.find_user_by_username(user_data['username']):
return {"message": "A user with that username already exists"}, 400
user = UserModel(**user_data)
user.save_to_db()
return {"message": "User created successfully."}, 201
def get(self):
claims = get_jwt_claims()
if not claims['is_admin']:
return {'message': 'admin previlege required'},400
current_user = UserModel.find_by_user(get_jwt_identity())
data = [statusL.json() for statusL in UserModel.find_by_status(current_user.businessId,'inactive')]
return data,200
def get(self):
user_id = get_jwt_identity()
if user_id:
user = UserModel.find_by_id(user_id)
return user.describe(complete=False), 200
return {
'users': [user.describe() for user in UserModel.find_all()]
}, 200
def post(self):
newUser = UserRegister.parser.parse_args()
if UserModel.find_by_username(newUser['username']):
return {'message': 'Username already exists'}, 400
user = UserModel(newUser['username'],
hash_password(newUser['password']), newUser['email'])
user.save_to_db()
return {'message': 'User created successfully'}
def post(self):
data = LoginUser.parser.parse_args()
if (UserModel.find_by_username(data['email'], data['password'])):
user = UserModel.find_by_username(data['email'], data['password'])
return user.json()
return {'message': 'Invalid login credential'}
def add_claims_to_jwt(identity):
if UserModel.find_by_user(identity).is_admin == 'is_admin': # instead of hard-coding, we should read from a config file to get a list of admins instead
return {'is_admin': True,'active':True,'is_superuser':False}
elif UserModel.find_by_user(identity).is_admin == 'is_superuser':
return {'is_superuser': True,'is_admin':True,'active':True}
elif UserModel.find_by_user(identity).status == 'active':
return {'active': True,'is_admin':False,'is_superuser':False}
return {'is_admin': False,'is_superuser':False,'active':False}
def password_reset(user_id, password):
user = UserModel.find_by_id(user_id)
if not user:
return {'msg': "Invalid User!!"}, 404
new_password = Hash_Password(password).hash_pwd()
UserModel.changePwd(user_id, new_password)
print(user.username)
return render_template('pwd_changed.html', username=user.username)
def post(self):
data = UserRegister.parser.parse_args()
row = UserModel.get_user_by_username(data['username'])
if row:
return {"message":"user already exist"},400
user = UserModel(**data)
user.save_to_db()
return {"message":"user created successfully."},201
def get(self):
claims = get_jwt_claims()
if not claims['active']:
return {
'message':
'Error # 25 in Order Resource, You have not been activated by the admin'
}, 400
username = UserModel.find_by_user(get_jwt_identity())
ztime = datetime.datetime.now().date()
ztime_31 = ztime - datetime.timedelta(31)
try:
child_list = HierarchyModel.find_by_child_of_code_single_user(
username.employeeCode)
child_list = [hier.json()['employee_code'] for hier in child_list]
except Exception as e:
print(e)
if len(child_list) == 0:
final_list = [username.employeeCode]
else:
try:
full_list = HierarchyModel.find_all_hierarchy()
full_list = [{
'child': hier.json()['employee_code'],
'parent': hier.json()['child_of_code']
} for hier in full_list]
except Exception as e:
print(e)
final_list = [username.employeeCode]
for i in final_list:
for j in full_list:
if i == j['parent']:
final_list.append(j['child'])
terminal_list = UserModel.find_by_user_list(final_list)
terminal_list = [term.json()['terminal'] for term in terminal_list]
try:
confirmedOrders = OpmobModel.find_confirmed(
terminal_list, ztime_31)
except Exception as e:
print(e)
return {'message': 'No orders created under your name'}, 400
invoice_no = ''
count = 0
for orders in confirmedOrders:
if invoice_no != orders.json()['invoice_no']:
count += 1
invoice_no = orders.json()['invoice_no']
else:
continue
return {'Number_of_confirmedOrders': count}, 200
def post(cls):
data = _global_parser.parse_args()
user = UserModel.find_by_username(data['username'])
if user and UserModel.verify_hash(data['password'], user.password):
access_token = create_access_token(identity=user.id)
return {
'access_token': access_token
}, 200
return {"message": "Invalid credentials."}, 401
def post(self):
data = UserRegister.parser.parse_args()
# check user exist or not
if UserModel.find_user_mapping(data['username']):
return {'message': 'user already exists'}, 400
user = UserModel(**data)
user.save_to_db()
return {'message': 'User create successfully.'}
def post(self):
received_data = SignUp.parser.parse_args()
if not(UserModel.getUserByName(received_data["username"]) in [None, -99]):
return({'message': 'An user with that name already exists!'}, 400)
newUser = UserModel(0, received_data['username'], received_data['password'])
if newUser.register():
return({'message': 'User has been signed up successfully!'}, 201)
else:
return({'Error': 'An Error occurred while creating user {0}!'.format(received_data['username'])}, 404)
def post(self):
data = attribute.parse_args()
if UserModel.find_by_login(data['login']):
return {
"message": "Login '{}' already exists.".format(data['login'])
}
user = UserModel(**data)
user.save_user()
return {'message': 'User created successfully'}, 201
def post(self):
data = self.parser.parse_args()
if UserModel.find_by_username(data["username"]):
return jsonify({"message": "User already exist in the database."})
user = UserModel(**data)
user.save_to_db()
return jsonify({"message": "User created successfully."})
def post(self):
data = RegisterUsers.parser.parse_args()
if UserModel.find_by_username(data['username']):
return {"message": "username already taken"}, 400
user = UserModel(**data)
user.save_to_db()
return {"message": "User registered successfully"}, 201 # created
def post(self):
data = _parser.parse_args()
if UserModel.find_by_username(data['username']):
return {'message': 'That username is already registered'}, 400
new_user = UserModel(**data)
new_user.save_to_db()
return {'message': 'User created successfully'}, 201
def post(self):
data = UserRegister.parser.parse_args()
if UserModel.find_by_email(data['email']):
return {"message": "User with that email 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': 'The username entered is already taken.'}, 400
user = UserModel(**data)
user.save_to_db()
return {'message': 'User created successfully.'}, 201
