def test_login_invalid_password(self):
# Initializing Service and invoking login(...)
user_service = UserService("test")
# Creating a user to login
response = user_service.register({
"email": "*****@*****.**",
"name": "John",
"password": "******",
"confirmPassword": "******",
"phone": "+11231231231"
})
user_id = response.user_id
# Trying to login
response = user_service.login({
"email": "*****@*****.**",
"password": "******"
})
# Validating the response
self.assertEqual(response, "Invalid Credentials")
# Deleting the user
user_service.delete_user(user_id)
def test_update_user_cannot_change_login(app):
with app.app_context():
user_service = UserService(app)
with pytest.raises(ValueError,
match=r"Login cannot be presented to update user*"):
updated_user = user_service.update(
id_entity=1, fields_to_update={'login': '******'})
def test_login(self):
# Initializing Service and invoking login(...)
user_service = UserService("test")
# Creating a user to login
response = user_service.register({
"email": "*****@*****.**",
"name": "John",
"password": "******",
"confirmPassword": "******",
"phone": "+11231231231"
})
user_id = response.user_id
# Trying to login
response = user_service.login({
"email": "*****@*****.**",
"password": "******"
})
# Validating the response
assert isinstance(response, User)
assert response.token is not None
assert response.user_id is not None
# Deleting the user
user_service.delete_user(user_id)
def setUp(self):
self.user_repository = UserRepository(test_database_connection())
self.user_service = UserService(self.user_repository)
self.user_repository.delete_all()
self.test_user_one = User('testuser', 'testuser1', 1)
self.test_user_two = User('secondo', 'testuser2', 2)
def register():
data = request.json
profile_data = data.pop('profile')
user = UserService().create(user_details=data,
profile_details=profile_data)
token = create_access_token(user)
return jsonify({"token": token}), 201
def login():
if request.method == 'GET':
return render_template("login.html")
req = request.form
username = req.get("uname")
password = req.get("psw")
user_svc = UserService()
try:
login_info = user_svc.login(username, password)
id_token = login_info.get("IdToken")
lex_token = id_token[:80]
# Creating Lex user session to talk to bot using the same ID token of Cognito
payload = {"user_id": lex_token}
payload_json = json.dumps(payload)
headers = {'Content-Type': 'application/json'}
response = requests.request("POST",
f"{LEX_PROXY_URL}/create_session",
headers=headers,
data=payload_json)
response_json = response.json()
print(f"INFO {response_json}")
session["session_token"] = id_token
session["lex_token"] = lex_token
return redirect(url_for('home'))
except Exception as e:
logging.warning(e)
return redirect(url_for('login'))
def setUp(self):
# Initializing Service and invoking register(...)
user_service = UserService("test")
user = user_service.register({
"email": "*****@*****.**",
"name": "John",
"password": "******",
"confirmPassword": "******",
"phone": "+11231231231"
})
self.user_id = user.user_id
self.headers['Authorization'] = self.__get_jwt_token(user.user_id)
self.board = {'name': 'board1', "color": "#fefefe"}
# Initializing BoardService and creating board
board_service = BoardService("test")
response = board_service.create_board(self.board, self.headers)
self.board_id = response.board_id
# Initializing SwimLaneService and creating a swim lane
swim_lane_service = SwimLaneService("test")
self.swim_lane = {
"title": "todo",
"boardId": self.board_id,
"position": "0"
}
response = swim_lane_service.create_swim_lane(self.swim_lane,
self.headers)
def transfer():
user_id = get_jwt_identity()
user = UserService().get_user_by_id(user_id)
data = {
'amount': request.json.get('amount', None),
'code': request.json.get('code', None),
'user_agent': request.headers.get('User-Agent'),
'ip': request.headers.get('ip-address'),
'location': request.headers.get('location'),
'author': user.get('username'),
'user_id': user_id
}
v = Validator(bank_transfer_validation_schema)
if v.validate(data):
wallet_service = WalletService(data)
if wallet_service.check_balance():
wallet_service.transfer()
return {"msg": "transaction success."}, 200
else:
return {
"msg": "user balance is not sufficient, transaction failed."
}, 400
return {
"msg": "validation error, transaction failed.",
"errors": v.errors
}, 400
def get(dbcontext: DbContext = Depends(get_dbcontext),
current_user: User = Depends(get_current_user),
page: Optional[int] = 1,
page_size: Optional[int] = 10) -> List[UserResponseSchema]:
users: List[User] = UserService(dbcontext).get_all(page, page_size)
return [UserResponseSchema.from_orm(user) for user in users]
class AdminPublishRequests(Resource):
ACCEPT_ACTION = 'accept'
DECLINE_ACTION = 'decline'
problem_service = ProblemService()
user_service = UserService()
@marshal_with(PublishRequest.api_fields)
def get(self):
return self.problem_service.get_all_publish_requests()
@jwt_required
@verify_attributes(["action"])
@marshal_with(Problem.api_fields)
def post(self):
user_id = get_jwt_identity()
data = request.get_json()
pr_id = data.get('id')
action = data.get('action')
if self.user_service.check_admin(user_id):
if action == self.ACCEPT_ACTION:
return self.problem_service.accept_publish_request(pr_id)
elif action == self.DECLINE_ACTION:
return self.problem_service.decline_publish_request(pr_id)
else:
raise BadRequest("'{}' action is not valid".format(action))
else:
raise Unauthorized("User with id {} is not admin".format(user_id))
def main():
user_repository = UserRepository()
user_service = UserService(user_repository)
console_io = ConsoleIO()
app = App(user_service, console_io)
app.run()
def login():
form = LoginForm()
if get_current_user() is None:
error = None
db = MongoInit().initialize()
if request.method == 'POST':
user = UserService(db).load_user_by_login(request.form['login'])
if user is None:
error = 'Invalid username or password'
elif user.password != request.form['password']:
error = 'Invalid username or password'
else:
login_user(user)
set_current_user(user)
return redirect(url_for('index'))
return render_template('login.html', error=error, form=form)
return redirect(url_for('index'))
def test_create_user_fail_none_entity_provided(app):
with app.app_context():
user_service = UserService(app)
with pytest.raises(
ValueError,
match=r"None object was provided to create new entity.*"):
user = user_service.create(None)
async def user_list(request):
"""
用户列表
:param request:
:return:
"""
if request.method == 'GET':
user_query = Users.select().filter(Users.deleted == 0)
cookie = request.cookies.get("user")
user = get_cookies(AGENT_COOKIE_TOKEN, cookie)
username = user.get('username')
is_admin = user.get('is_admin')
kargs = {}
kargs['username'] = username
kargs['is_admin'] = is_admin
kargs['id'] = request.args.get("id", "")
kargs['phone'] = request.args.get("phone", "")
kargs["username"] = request.args.get("username", "")
kargs["level"] = request.args.get("level", "")
kargs["agent_id"] = request.args.get("agent_id", "")
kargs["is_admin"] = request.args.get("is_admin", "")
query = UserService().user_list(**kargs)
data = get_page_data(request, query)
return jinja.render("admin/user-list.html",
request,
kargs=kargs,
data=data,
user_query=user_query)
elif request.method == "POST":
id = request.form.get("id")
Users.update({Users.deleted: 1}).where(Users.id == id).execute()
return text("已删除")
def download_candidate_resume(pk):
resume = UserService().get_user_resume(pk)
if resume:
return send_file(resume,
as_attachment=True,
attachment_filename='resume.pdf',
mimetype="application/pdf")
raise TinyHRError("Resume was not uploaded.", 404)
def test_create_user(app):
with app.app_context():
user_service = UserService(app)
user = User()
user.login = '******'
user.password = '******'
user = user_service.create(user)
assert user.id is not None
def index(dbcontext: DbContext = Depends(get_dbcontext),
schema: RegisterRequestSchema = None):
try:
user = UserService(dbcontext).create(schema.__dict__)
return {"id": user.id}
except IntegrityError:
raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST,
detail=f"{schema.email} already exists!!!")
class UserAuth(Resource):
user_service = UserService()
@verify_attributes(['tokenId'])
def post(self):
data = request.get_json()
token = data.get('tokenId')
return {"jwt": get_jwt_user(token)}
class UserDetail(Resource):
user_service = UserService()
@jwt_required
@marshal_with(User.api_fields)
def get(self):
id = get_jwt_identity()
return self.user_service.get_user_by_id(id)
def test_delete_by_id(app):
with app.app_context():
user_service = UserService(app)
user = User()
user.login = '******'
user.password = '******'
user = user_service.create(user)
user_service.delete_by_id(user.id)
assert user_service.get_by_id(user.id) is None
def get_jwt_user(token):
CLIENT_ID = environ['CLIENT_ID']
try:
userinfo = id_token.verify_oauth2_token(token, requests.Request(),
CLIENT_ID)
except Exception as e:
raise BadRequest(str(e))
name = userinfo['name']
email = userinfo['email']
auth = UserAuth.query.get(email)
if not auth:
user = UserService().create_user(name, email)
auth = UserAuth(email=email, user=user)
db.session.add(auth)
db.session.commit()
else:
user = UserService().get_user_by_email(email)
print(user._id is None)
return create_access_token(identity=user._id)
def test_update_user_cannot_assign_bad_column(app):
with app.app_context():
user_service = UserService(app)
user = User()
user.login = '******'
user.password = '******'
user = user_service.create(user)
with pytest.raises(ValueError,
match=r"Model definition does not have such key*"):
updated_user = user_service.update(user.id, {'metadata': 'test'})
def test_get_by_id(app):
with app.app_context():
user_service = UserService(app)
user = User()
user.login = '******'
user.password = '******'
user = user_service.create(user)
assert user_service.get_by_id(
user.id).id == user.id and user_service.get_by_id(
user.id).login == user.login
def get_by_email(
email: str,
dbcontext: DbContext = Depends(get_dbcontext),
current_user: User = Depends(get_current_user),
) -> UserResponseSchema:
user: User = UserService(dbcontext).get_by_email(email)
if user is None:
raise HTTPException(status_code=status.HTTP_204_NO_CONTENT,
detail=f"{email} doesn't exists")
return UserResponseSchema.from_orm(user)
def test_login_invalid_email(self):
# Initializing Service and invoking login(...)
user_service = UserService("test")
# Trying to login with invalid user email
response = user_service.login({
"email": "*****@*****.**",
"password": "******"
})
# Validating the response
self.assertEqual(response, "User not available")
def setUp(self):
self.password_repository = PasswordRepository(test_database_connection())
self.password_service = PasswordService(self.password_repository)
self.password_repository.delete_all_passwords()
self.user_repository = UserRepository(test_database_connection())
self.user_service = UserService(self.user_repository)
self.test_user_one = User("test_user_one", "test_pw1")
self.test_user_two = User("test_user_two", "test_pw2")
self.user_service.create_user(self.test_user_one)
self.user_service.create_user(self.test_user_two)
def get_user_session(code):
config = ConfigReader().get_config()
app_id = config.get("wechat", "app_id")
secret = config.get("wechat", "secret")
user_session_url = config.get("wechat", "user_session_url")
url = user_session_url + app_id + '&secret=' + secret + '&grant_type=authorization_code&js_code=' + code
user_session_from_wechat = requests.get(url)
user_service = UserService()
if user_session is not None:
user_service.handle_user_session(json.loads(user_session_from_wechat.text).get('openid'))
return Response(user_session_from_wechat.text)
return Response('failed')
def __init__(self):
self.user_service = UserService()
self.parser = reqparse.RequestParser()
self.parser.add_argument('login',
type=str,
required=True,
help='Login cannot be en empty string.')
self.parser.add_argument('password',
type=str,
required=True,
help='Password cannot be en empty string.')
def create_admin(first_name, last_name, email, password):
try:
UserService().create(user_details={
"first_name": first_name,
"last_name": last_name,
"email": email,
"password": password
},
is_admin=True)
print(f"User '{email}' was created successfully.")
except TinyHRError:
print(f"User with email ({email}) already exists")
def __init__(self, root, handle_login_view):
"""Rekisteröitymisnäkymästä vastaava käyttöliittymäluokka
Args:
root: Juurielementti, joka hallitsee nykyistä näkymää
handle_login_view: UI-luokan metodi, joka siirtää näkymän LoginViewiin
"""
self._root = root
self._frame = None
self._initialize()
self._handle_login_view = handle_login_view
self._user_service = UserService()
