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()