def signup_user(data, is_admin):
user = User.query.filter_by(email=data['email']).first()
if not user:
new_user = User(public_id=str(uuid.uuid4()),
email=data['email'],
username=data['username'],
password=data['password'],
phone=data['phone'],
admin=True if is_admin is True else False,
registered_on=datetime.datetime.utcnow())
save_changes(new_user)
try:
# generate the auth token
auth_token = User.encode_auth_token(new_user.id)
response_object = {
'status': 'success',
'message': 'Successfully registered.',
'Authorization': auth_token.decode()
}
return response_object, 201
except Exception as e:
response_object = {
'status': 'fail',
'message': 'Some error occurred. Please try again.'
}
return response_object, 401
else:
response_object = {
'status': 'fail',
'message': 'User already exists. Please Log in.',
}
return response_object, 409
def update_user(data, request):
user, status, error = Auth.get_logged_in_user(request)
if not user:
response_object = {'status': 'error', 'message': error}
return response_object, status
try:
fields = validate_update(model=user, data=data)
# assign fields with extra validation for some attributes
for field, value in fields.items():
if field == 'email':
User.validate_email(user, key='email', email=data['email'])
setattr(user, field, data[field])
save_changes()
except AssertionError as error:
response_object = {'status': 'error', 'message': str(error)}
return response_object, 400
response_object = {
'status': 'success',
'message': 'User updated.',
}
return response_object, 200
def save_new_user(data):
user = User.query.filter_by(email=data['email']).first()
if not user:
new_user = User(
public_id=data['public_id'],
email=data['email'],
username=data['username'],
password=data['password'],
level_cd=data['level_cd'],
user_role=data['user_role'],
reg_datetime=datetime.datetime.utcnow(),
memo="",
)
if data['level_cd'] == '99': # super admin
new_user.is_admin = True
else:
new_user.is_admin = False
user_detail = UserDetail(
public_id=data['public_id'],
address=data['address'],
phone_number=data['phone_number'],
reg_datetime=datetime.datetime.utcnow(),
)
save_changes(new_user, user_detail) # insert to DB
return generate_token(new_user)
else:
response_object = {
'status': 'fail',
'message': 'User email already exists. Please Log in.',
}
return response_object, 409
def initdb():
"""Create db tables and init data"""
db.drop_all()
db.create_all()
user_admin = User(name='admin',
password='******',
type=1,
state=1,
create_time=time.strftime('%Y-%m-%d %X',
time.localtime()))
user_manager = User(name='manager',
password='******',
type=2,
state=1,
create_time=time.strftime('%Y-%m-%d %X',
time.localtime()))
user_guest = User(name='guest',
password='******',
type=3,
state=1,
create_time=time.strftime('%Y-%m-%d %X',
time.localtime()))
db.session.add(user_admin)
db.session.add(user_manager)
db.session.add(user_guest)
def get_logged_in_user(new_request):
# get the auth token
auth_token = new_request.headers.get('Authorization')
if auth_token:
resp = User.decode_auth_token(auth_token)
if not isinstance(resp, str):
user = User.objects(id=resp)[0]
response_object = {
'status': 'success',
'data': {
'user_id': user.id,
'email': user.email,
'registered_on': str(user.registered_on)
}
}
return response_object, 200
response_object = {
'status': 'fail',
'message': resp
}
return response_object, 401
else:
response_object = {
'status': 'fail',
'message': 'Provide a valid auth token.'
}
return response_object, 401
def save_new_user(data):
user = User.query.filter_by(username=data['username']).first()
if not user:
if 'email' in data:
new_user = User(public_id=data['username'],
email=data['email'],
username=data['username'],
password=data['password'],
registered_on=datetime.datetime.utcnow(),
level=1)
save_changes(new_user)
return generate_token(new_user)
else:
new_user = User(public_id=data['username'],
email=None,
username=data['username'],
password=data['password'],
registered_on=datetime.datetime.utcnow(),
level=1)
save_changes(new_user)
return generate_token(new_user)
else:
response_object = {
'status': 'fail',
'message': 'User already exists. Please Log in.',
}
return response_object, 409
def test_encode_auth_token(self):
user = User(email='*****@*****.**',
password='******',
registered_on=datetime.datetime.utcnow())
db.session.add(user)
db.session.commit()
auth_token = user.encode_auth_token(user.id)
self.assertTrue(isinstance(auth_token, bytes))
def test_decode_auth_token(self):
user = User(password='******', registered_on=datetime.datetime.utcnow())
db.session.add(user)
db.session.commit()
auth_token = user.encode_auth_token(user.id)
self.assertTrue(isinstance(auth_token, bytes))
self.assertTrue(
User.decode_auth_token(auth_token.decode("utf-8")) == 1)
def test_encode_auth_token(self):
user = User(email='*****@*****.**',
password='******',
registered_on=datetime.datetime.utcnow())
db.session.add(user)
db.session.commit()
ret, auth_token = user.encode_auth_token(user.id, 'test_key')
self.assertTrue(ret)
def save_user_to_db_and_get_token():
user = User(email='*****@*****.**',
password='******',
created_at=datetime.datetime.utcnow(),
updated_at=datetime.datetime.utcnow())
db.session.add(user)
db.session.commit()
auth_token = user.encode_auth_token(user.id)
return auth_token
def test_encode_auth_token(self):
user = User(email='*****@*****.**',
password='******',
registration_date=datetime.utcnow())
db.session.add(user)
db.session.commit()
auth_token = user.encode_auth_token(user.public_id)
self.assertTrue(isinstance(auth_token, bytes))
def test_encode_auth_token(self):
user = User(email='*****@*****.**',
password='******',
reg_datetime=datetime.datetime.utcnow(),
user_role='inspector',
level_cd='11')
db.session.add(user)
db.session.commit()
auth_token = user.encode_auth_token(user.id)
self.assertTrue(isinstance(auth_token, bytes))
def load_db():
with app.app_context():
User.query.delete()
db.session.commit()
for data in samples:
user = User(**dict(zip(attrs, data)))
if user.username=='Admin':
user.is_admin = True
db.session.add(user)
db.session.commit()
print(User.query.all())
def test_decode_auth_token(self):
user = User(
email="*****@*****.**",
registered_on=datetime.datetime.utcnow(),
password="******"
)
db.session.add(user)
db.session.commit()
auth_token = User.encode_auth_token(user.id)
self.assertTrue(isinstance(auth_token, bytes))
self.assertTrue(User.decode_auth_token(auth_token) == 1)
def test_decode_auth_token(self):
user_id = uuid.uuid4()
user = User(email='*****@*****.**',
id=user_id,
username='******',
password='******',
registered_on=datetime.datetime.utcnow())
db.session.add(user)
db.session.commit()
auth_token = user.encode_auth_token(user.id)
self.assertEqual(User.decode_auth_token(auth_token), user.id)
def test_decode_auth_token(self):
user = User(email='*****@*****.**',
password='******',
joined_at=datetime.datetime.utcnow())
db.session.add(user)
db.session.commit()
auth_token = User.encode_auth_token(user.id)
self.assertTrue(isinstance(auth_token, bytes))
self.assertTrue(
User.decode_auth_token(auth_token.decode("utf-8")) == 1)
def test_decode_auth_token(self):
user = User(email='*****@*****.**',
password='******',
registered_on=datetime.datetime.utcnow(),
public_id=str(uuid.uuid4()),
username='******')
db.session.add(user)
db.session.commit()
auth_token = user.encode_auth_token(user.id)
self.assertTrue(isinstance(auth_token, bytes))
self.assertTrue(
User.decode_auth_token(auth_token.decode('utf-8')) == 1)
def test_decode_auth_token(self):
user = User(email='*****@*****.**',
password='******',
reg_datetime=datetime.datetime.utcnow(),
user_role='worker',
level_cd='01')
db.session.add(user)
db.session.commit()
auth_token = user.encode_auth_token(user.id)
self.assertTrue(isinstance(auth_token, bytes))
self.assertTrue(
User.decode_auth_token(auth_token.decode("utf-8")) == 1)
def save_new_user(data: Dict[str,str]) -> Dict[str,str]:
"""
Store user into database
"""
# Check if user exist
email = data['mail']
username = data['username']
user = User.query.filter((User.mail == email) | (User.username == username)).first()
response_object = {
'status': 0,
'message': '',
'error_message': '',
'data': {}
}
if user:
repeated_value = email if user.mail == email else username
repeated_key = 'email' if user.mail == email else 'username'
# User exist, do not continue
response_object['status'] = 409
response_object['error_message'] = 'User with {0} [{1}] already exist'.format(repeated_key, repeated_value)
return response_object
# Create user
new_user = User(
name=data['name'],
lastname=data['lastname'],
mail=email,
username=username,
password=data['password']
)
# new_user.password = data['password']
db.session.add(new_user)
db.session.commit()
serialized_user = new_user.serialize()
response_object['status'] = 201
response_object['message'] = 'User created'
response_object['data'] = {
'user': serialized_user,
'token': generate_auth_token_for_user(new_user)
}
save_new_event('[REGISTER] User with id [{0}] has been registered'.format(serialized_user['id']))
return response_object
def test_decode_auth_token(self):
user = User(
email="*****@*****.**",
password="******",
registered_on=datetime.datetime.utcnow(),
)
db.session.add(user)
db.session.commit()
auth_token = User.encode_auth_token(user)
self.assertTrue(isinstance(auth_token, bytes))
sub, scope = User.decode_auth_token(auth_token.decode("utf-8"))
self.assertTrue(sub == user.id)
self.assertTrue(scope == False)
def test_encode_auth_token(self):
user = User(
first_name='Test',
last_name='User',
language='en',
personal_phone='555-555-5555',
email='*****@*****.**',
password='******',
registered_on=datetime.datetime.utcnow()
)
db.session.add(user)
db.session.commit()
auth_token = user.encode_auth_token(user.id)
self.assertTrue(isinstance(auth_token, bytes))
def delete_user(data):
try:
User.objects(publicId=data['publicId']).delete()
response_object = {
'status': Const.SUCCESS,
'message': Const.USER_DELETE_SUCCESS
}
return response_object, Const.SUCCESS_CODE
except Exception as e:
response_object = {
'status': Const.FAIL,
'message': e
}
return response_object, Const.FAILURE_CODE
def save_new_user(data):
user = User.objects(email=data["email"])
if not user:
hashed_password = flask_bcrypt.generate_password_hash(
data['password']).decode('utf-8')
new_user = User(username=data["username"],
email=data["email"],
first_name=data["first_name"],
last_name=data["last_name"],
password=hashed_password)
new_user.save()
logger.debug("NEW USER CREATED: ", new_user)
return generate_token(new_user)
else:
return ResponseObject.user_reg(success=False)
def save_new_user(data):
public_id = str(uuid.uuid4())
new_user = User(
public_id=public_id,
email=data.get('email', None),
)
if data.get('password', None):
new_user.password = data.get('password', None)
try:
save_changes(new_user)
data['publicId'] = public_id
return data
except Exception as e:
return {'error': str(e)}
def test_encode_auth_token(self):
user = User(
nickName='Alex👀',
gender=1,
language='zh_CN',
city='Guangzhou',
province='Guangdong',
country='China',
avatarUrl=
'https://wx.qlogo.cn/mmopen/vi_32/xSNc6wVNtlY6z28PgU4tdJRNshhOgDlsXBuLbzGmtFSylccMFqoYaGC4RjjQjZcbsnt97KF3icHa3lFHHmH439A/132',
registered_on=datetime.datetime.utcnow())
db.session.add(user)
db.session.commit()
auth_token = User.encode_auth_token(user.id)
self.assertTrue(isinstance(auth_token, bytes))
def save_satellite(data, auth_header):
id = User.decode_auth_token(auth_header)
address = data['address']
if address:
satellite_name = data['satellite_name']
address = data['address']
is_active = data['is_active']
user_id = id
if user_id:
satellite = Satellite(satellite_name, address, is_active, user_id)
satellite.save()
response = jsonify({
'satellite_name': satellite.satellite_name,
'created_at': satellite.created_at
})
response.status_code = 201
return response
else:
response_object = {
'status': 'fail',
'message': 'satellite save action not success',
}
return response_object, 409
else:
response_object = {
'status': 'fail',
'message': 'Something went wrong',
}
return response_object, 409
def update_satellite(data, auth_header):
user_id = User.decode_auth_token(auth_header)
id = data['id']
satellite = Satellite.query.filter_by(user_id=user_id,id=id).first()
if satellite:
satellite.satellite_name = data['satellite_name']
satellite.address = data['address']
satellite.is_active = data['is_active']
satellite.save()
response = jsonify({
'status': 'success',
'message': 'satellite details update action success',
'device_name': satellite.is_active,
'mac_address': satellite.address
})
response.status_code = 201
return response
else:
response_object = {
'status': 'fail',
'message': 'satellite details update action not success',
}
return response_object, 409
def first(*args):
if len(args[0]) < 2:
print("Usage: python manage.py create_admin [user] [password] ")
admin = User(public_id=str(uuid.uuid4()),
email="admin",
username=sys.argv[2],
password=sys.argv[3],
admin=True,
registered_on=datetime.datetime.utcnow())
food_container = FoodContainer(food_percentage=58,
capacity=2,
last_filled=datetime.datetime.now())
schd = Schedule(meal_per_day=0,
first_meal_hour=0,
first_meal_minute=0,
interval_hour=0,
interval_minute=0)
db.session.add(admin)
db.session.add(food_container)
db.session.add(schd)
db.session.commit()
def get_logged_in_user(new_request):
# get the auth token
auth_token = new_request.headers.get('Authorization')
auth_token = auth_token.split(" ")[1]
if auth_token:
resp = User.decode_auth_token(auth_token)
if not isinstance(resp, str):
user = User.query.filter_by(id=resp).first()
response_object = {
'status': 'success',
'data': {
'user_id': user.id,
'admin': user.admin,
'registered_on': str(user.registered_on)
}
}
return response_object, 200
response_object = {'status': 'fail', 'message': resp}
return response_object, 401
else:
response_object = {
'status': 'fail',
'message': 'Provide a valid auth token.'
}
return response_object, 401
def save_new_user(data):
"""Saves a new user.
Args:
data: The user data.
Returns:
The response object.
"""
user = User.query.filter_by(email=data['email']).first()
if not user:
new_user = User(public_id=str(uuid.uuid4()),
email=data['email'],
username=data['username'],
password=data['password'],
registered_on=datetime.datetime.utcnow())
save_changes(new_user)
response_object = {
'status': 'success',
'message': 'Successfully registered.'
}
return response_object, 201
else:
response_object = {
'status': 'fail',
'message': 'User already exists. Please Log in.',
}
return response_object, 409
def test_verify_password(self):
user = User(password='******')
self.assertTrue(user.verify_password('test123'))
