def test_get(self): """ The GET on `/user` should return an user """ UserRepository.create(first_name='John', last_name='Doe', age=25) response = self.client.get('/application/user/Doe/John') self.assertEqual(response.status_code, 200) response_json = json.loads(response.data.decode('utf-8')) self.assertEqual(response_json, {'user': {'age': 25, 'first_name': 'John', 'last_name': 'Doe'}})
def test_get(self): UserRepository.create(id='curso-departamento-pessoal---presencial-manha__534240') response = self.client.get('/application/event/curso-departamento-pessoal---presencial-manha__534240') self.assertEqual(response.status_code, 200) response_json = json.loads(response.data.decode('utf-8')) self.assertEqual( response_json, {'event': {'id': 'curso-departamento-pessoal---presencial-manha__534240'}} )
def test_get(self): """ The GET on `/user` should return an user """ UserRepository.create(first_name="John", last_name="Doe", age=25) response = self.client.get("/application/user/Doe/John") self.assertEqual(response.status_code, 200) response_json = json.loads(response.data.decode("utf-8")) self.assertEqual( response_json, {"user": {"age": 25, "first_name": "John", "last_name": "Doe"}}, )
def test_create(self, mock_decorator): """ The POST on `/user` should create an user """ UserRepository.create(first_name='John', last_name='Doe', age=25) response = self.client.post( '/api/users/Doe/John', content_type='application/json', headers={'Authorization': 'Bearer token'}, data=json.dumps({ 'age': 30 }) ) self.assertEqual(response.status_code, 400)
def test_update(self): """ The PUT on `/user` should update an user's age """ UserRepository.create(first_name='John', last_name='Doe', age=25) response = self.client.put( '/application/user/Doe/John', content_type='application/json', data=json.dumps({ 'age': 30 }) ) self.assertEqual(response.status_code, 200) response_json = json.loads(response.data.decode('utf-8')) self.assertEqual(response_json, {'user': {'age': 30, 'first_name': 'John', 'last_name': 'Doe'}}) user = UserRepository.get(first_name='John', last_name='Doe') self.assertEqual(user.age, 30)
def test_update(self): """ The PUT on `/user` should update an user's info""" user = UserRepository.create(first_name="John", last_name="Doe") response = self.client.put( "/application/user/{}".format(user.id), content_type="application/json", data=json.dumps( dict(first_name="John", last_name="Doe", emails=["*****@*****.**"], phone_numbers=["+491424324435"])), ) self.assertEqual(response.status_code, 200) response_json = json.loads(response.data.decode("utf-8")) self.assertEqual( response_json, { "user": dict(user_id=user.id, first_name="John", last_name="Doe", emails=["*****@*****.**"], phone_numbers=["+491424324435"]) }, ) user = UserRepository.get(user_id=user.id) self.assertEqual(user.first_name, "John")
def post(last_name, first_name, emails, phone_numbers): """ Create an user based on the sent information """ user = UserRepository.create(last_name=last_name, first_name=first_name, emails=emails, phone_numbers=phone_numbers) return jsonify({"user": user.json})
def create(): """ Create a auth """ body = request.get_json() auth = AuthRepository.getByUsername(body["username"].lower()) expires = datetime.timedelta(days=1) if not auth: pw_hash = generate_password_hash(body["password"], 10) auth = AuthRepository.create(body["username"].lower(), pw_hash) user = UserRepository.create(body["username"], None, None) expires = datetime.timedelta(days=1) # access_token = create_access_token(identity = { "username": auth.username, "id": auth.id }, expires_delta=expires) access_token = create_access_token(identity={ "username": auth.username, "id": auth.id }) response = jsonify({"success": True, "access_token": access_token}) response.status_code = 200 return response validatePassword = check_password_hash(auth.password, body["password"]) if not validatePassword: response = jsonify({ "success": False, "message": "Invalid username or password" }) response.status_code = 200 return response access_token = create_access_token(identity={ "username": auth.username, "id": auth.id }) AuthRepository.updateToken(id=auth.id, token=access_token) response = jsonify({"success": True, "access_token": access_token}) response.status_code = 200 return response
def auth_wrapper(*args, **kwargs): try: auth_header = request.headers['Authorization'] token = auth_header.split(' ')[1] id_info = id_token.verify_oauth2_token(token, requests.Request(), config.GOOGLE_CLIENT_ID) oid = id_info["sub"] picture = id_info["picture"] name = id_info["name"] email = id_info["email"] user = UserRepository.get(oid) if user: user = UserRepository.update(oid, email, picture, name) else: user = UserRepository.create(oid, email, picture, name) if 'oid' in kwargs: if kwargs['oid'] != user.oid: return render_error( "You don't have right access to this page", 403) kwargs.update({'user': user}) return method(*args, **kwargs) except Exception as exc: return render_error(str(exc), 401)
def post(email: str, password: str): if UserRepository.find_by_email(email): return {"message": "Email already exits"}, 400 else: user = UserRepository.create( email=email, password=generate_password_hash(password)) return user.json
def post(last_name, first_name, email, age, gender): """ Create an user based on the sent information """ user = UserRepository.create(last_name=last_name, first_name=first_name, email=email, age=age, gender=gender) return jsonify({"user": user.json})
def post(key, last_name, first_name, age): print(key, last_name, first_name) """ Create an user based on the sent information """ user = UserRepository.create(key=key, last_name=last_name, first_name=first_name, age=age) return jsonify({"user": user.json})
def post(last_name, first_name, age): """ Create an user based on the sent information """ user = UserRepository.create( last_name=last_name, first_name=first_name, age=age ) return jsonify({'user': user.json})
def test_update(self): """ The PUT on `/user` should update an user's age """ UserRepository.create(first_name="John", last_name="Doe", age=25) response = self.client.put( "/application/user/Doe/John", content_type="application/json", data=json.dumps({"age": 30}), ) self.assertEqual(response.status_code, 200) response_json = json.loads(response.data.decode("utf-8")) self.assertEqual( response_json, {"user": {"age": 30, "first_name": "John", "last_name": "Doe"}}, ) user = UserRepository.get(first_name="John", last_name="Doe") self.assertEqual(user.age, 30)
def post(self): """ Sign Up """ parser = reqparse.RequestParser() parser.add_argument("name", type=str, location="form") parser.add_argument("password", type=str, location="form") parser.add_argument("nickname", type=str, location="form") # parser.add_argument('profile', type=werkzeug.datastructures.FileStorage, location='files') args = parser.parse_args() name = args["name"] password = args["password"] nickname = args["nickname"] # profile_file = args['profile'] profile = name + ".jpg" # profile_file.save(profile) try: hash = generate_password_hash(password, method="sha256") user = UserRepository.create(name, hash, nickname, profile) print("User created", user) token = jwt.encode( { "id": user["id"], "username": user["name"], "exp": datetime.datetime.utcnow() + datetime.timedelta(minutes=30), }, "SECRET", ) response = { "data": { "user": user, "csrf_token": token }, "code": 200, "messages": [{ "content": "Success", "type": 4 }], } status_code = 200 return response, status_code, { "Content-Type": "json; charset=utf-8" } except Exception as e: print(e) response = { "data": {}, "code": 400, "messages": [{ "content": "Fail", "type": 1 }], } return response, 400, {"Content-Type": "json; charset=utf-8"}
def post(username, password, name, type): ensure_user(user_type="admin") if UserRepository.get(username) is not None: abort(400, msg="existing user") user = UserRepository.create(username, password, name, type) user_json = user.json del user_json["password"] return user_json, 200
def post(user_email, user_name, password, is_safe): """ Create an user based on the sent information """ user = UserRepository.create( user_name=user_name, user_email=user_email, age=age, is_safe=is_safe ) return jsonify({'user': user.json})
def post(username, hashed_password): """ Create an user based on the sent information """ try: user = UserRepository.create(username=username, hashed_password=hashed_password) access_token = create_access_token(identity=username) return jsonify({"access_token": access_token}) except: return abort(403, description="Username already exists!")
def post(last_name, first_name, age): """ Create an user based on the sent information """ existing_user = UserRepository.get(last_name=last_name, first_name=first_name) if existing_user: return bad_request('user already in database') user = UserRepository.create(last_name=last_name, first_name=first_name, age=age) if user: return jsonify({'user': user.json}) return bad_request('unable to create user')
def post(self): """Create user.""" request_json = request.get_json(silent=True) username: str = request_json.get('username') avatar_url: str = request_json.get('avatar_url', '') password: str = request_json.get('password') try: user = UserRepository.create(username, avatar_url, password) return user, 200 except ResourceExists: response = {"message": "user already exists."}, 400 except Exception as ex: response = {"message": str(ex)}, 500 return response
def post(self): """ Create user """ request_json = request.get_json(silent=True) username: str = request_json['username'] avatar_url: str = request_json.get('avatar_url', '') try: user = UserRepository.create(username, avatar_url) return user, 200 except Exception as e: response = jsonify(e.to_dict()) response.status_code = e.status_code return response
def test_get(self): """ The GET on `/user` should return an user """ user = UserRepository.create(first_name="John", last_name="Doe", emails=["*****@*****.**"], phone_numbers=["+491424324435"]) response = self.client.get("/application/user/{}".format(user.id)) self.assertEqual(response.status_code, 200) response_json = json.loads(response.data.decode("utf-8")) self.assertEqual( response_json, { "user": dict(user_id=user.id, first_name="John", last_name="Doe", emails=["*****@*****.**"], phone_numbers=["+491424324435"]) }, )
def post(last_name, first_name, age): """ Create an user based on the sent information --- tags: - user parameters: - name: last_name in: path type: string description: the last name of the user - name: first_name in: path type: string description: the last name of the user - name: body in: body schema: type: object properties: age: type: integer description: The age of the user responses: 200: description: The user was successfully created schema: example: user: last_name: Doe first_name: John age: 30 """ user = UserRepository.create( last_name=last_name, first_name=first_name, age=age ) return jsonify({'user': user.json})
def post(username, email, password): user = UserRepository.create( username=username, email=email, password=password ) return jsonify({"data": user})
def post(email, password, first_name, last_name): repository = UserRepository() token = repository.create(email, password, first_name, last_name) return jsonify(token=token.decode("utf-8")), 201
def post(self, new_data): """Add a new user""" result, created = UserRepository.create(**new_data) if not created: abort(409, message="User already exists.") return result
def post(username, age): """ Create an user based on the sent information """ user = UserRepository.create( username=username, age=age ) return jsonify({"user": user.json})
def test_get(self): """ The GET on `/user` should return an pdf file """ UserRepository.create(first_name="John", last_name="Doe", age=25) response = self.client.get("/application/user/Doe") self.assertEqual(response.status_code, 200)