def session_login() -> str:
""" POST /api/v1/auth_session/login
JSON body:
- email
- password
Return:
- User object JSON represented
"""
user_email = request.form.get('email')
user_pswd = request.form.get('password')
if user_email is None:
return jsonify({"error": "email missing"}), 400
if user_pswd is None:
return jsonify({"error": "password missing"}), 400
try:
search_users = User.search({'email': user_email})
except Exception:
return jsonify({"error": "no user found for this email"}), 404
if not search_users:
return jsonify({"error": "no user found for this email"}), 404
for user in search_users:
if user.is_valid_password(user_pswd):
from api.v1.app import auth
session_cookie = getenv("SESSION_NAME")
session_id = auth.create_session(user.id)
response = jsonify(user.to_json())
response.set_cookie(session_cookie, session_id)
return response
else:
return jsonify({"error": "wrong password"}), 401
def login():
""" POST /auth_session/login
Return
- Logged in user
"""
email = request.form.get('email')
if not email:
return jsonify({"error": "email missing"}), 400
password = request.form.get('password')
if not password:
return jsonify({"error": "password missing"}), 400
try:
found_users = User.search({'email': email})
except Exception:
return jsonify({"error": "no user found for this email"}), 404
if not found_users:
return jsonify({"error": "no user found for this email"}), 404
for user in found_users:
if not user.is_valid_password(password):
return jsonify({"error": "wrong password"}), 401
from api.v1.app import auth
user = found_users[0]
session_id = auth.create_session(user.id)
SESSION_NAME = getenv("SESSION_NAME")
response = jsonify(user.to_json())
response.set_cookie(SESSION_NAME, session_id)
return response
def auth_sess_login():
""" POST /api/v1/auth_session/login
Return:
- dict repr of User
"""
u_email = request.form.get('email')
u_pwd = request.form.get('password')
if u_email is None or u_email == "":
return jsonify({"error": "email missing"}), 400
if u_pwd is None or u_pwd == "":
return jsonify({'error': 'password missing'}), 400
emailSearch = User.search({'email': u_email})
if emailSearch == []:
return jsonify({"error": "no user found for this email"}), 404
for user in emailSearch:
if user.email == u_email and not user.is_valid_password(u_pwd):
return jsonify({"error": "wrong password"}), 401
else:
from api.v1.app import auth
get_sess_name = os.getenv('SESSION_NAME')
make_sess_id = auth.create_session(user.id)
response = jsonify(user.to_json())
response.set_cookie(get_sess_name, make_sess_id)
return response
def session_login() -> str:
""" handles all routes for the Session authentication """
email = request.form.get('email')
if not email:
return jsonify({"error": "email missing"}), 400
password = request.form.get('password')
if not password:
return jsonify({"error": "password missing"}), 400
try:
user = User.search({'email': email})
except Exception:
user = None
if user:
validate_password = user[0].is_valid_password(password)
if not validate_password:
return jsonify({"error": "wrong password"}), 401
from api.v1.app import auth
session_id = auth.create_session(user[0].id)
user_dict = jsonify(user[0].to_json())
cookie = os.getenv('SESSION_NAME')
user_dict.set_cookie(cookie, session_id)
return user_dict
else:
return jsonify({"error": "no user found for this email"}), 404
def login():
""" POST /auth_session/login
Return:
- User instance based on email
"""
email = request.form.get('email')
password = request.form.get('password')
if not email:
return jsonify({"error": "email missing"}), 400
if not password:
return jsonify({"error": "password missing"}), 400
try:
users = User.search({'email': email})
except Exception:
return jsonify({"error": "no user found for this email"}), 404
if not users:
return jsonify({"error": "no user found for this email"}), 404
for u in users:
if not u.is_valid_password(password):
return jsonify({"error": "wrong password"}), 401
from api.v1.app import auth
session_id = auth.create_session(u.id)
out = jsonify(u.to_json())
out.set_cookie(getenv('SESSION_NAME'), session_id)
return out
return jsonify({"error": "no user found for this email"}), 404
def auth_login():
""" Auth Login
"""
from api.v1.app import auth
email = request.form.get('email', None)
if email is None or len(email) == 0:
return jsonify({"error": "email missing"}), 400
pwd = request.form.get('password')
if pwd is None or len(pwd) == 0:
return jsonify({"error": "password missing"}), 400
users = User.search({"email": email})
if len(users) == 0:
return jsonify({"error": "no user found for this email"}), 404
for user in users:
if user.is_valid_password(pwd):
response = make_response(user.to_json())
SESSION_NAME = os.getenv('SESSION_NAME')
response.set_cookie(SESSION_NAME, auth.create_session(user.id))
return response
return jsonify({"error": "wrong password"}), 401
def login() -> str:
"""Dictionary representation of the User authenticated
"""
email = request.form.get('email')
password = request.form.get('password')
if not email:
return jsonify({"error": "email missing"}), 400
if not password:
return jsonify({"error": "password missing"}), 400
user_not_found_error = {"error": "no user found for this email"}
try:
users = User.search({'email': email})
except KeyError:
return jsonify(user_not_found_error), 404
if len(users) == 0:
return jsonify(user_not_found_error), 404
for user in users:
if user.is_valid_password(password):
# Create session
from api.v1.app import auth
session_id = auth.create_session(user_id=user.id)
response = jsonify(user.to_json())
response.set_cookie(getenv('SESSION_NAME'), session_id)
return response
return jsonify({"error": "wrong password"}), 401
def login():
"""Login
"""
email = request.form.get('email')
if not email:
return jsonify({"error": "email missing"}), 400
psswrd = request.form.get('password')
if not psswrd:
return jsonify({"error": "password missing"}), 400
try:
users = User.search({'email': email})
except Exception:
return jsonify({"error": "no user found for this email"}), 404
for user in users:
if not user.is_valid_password(psswrd):
return jsonify({"error": "wrong password"}), 401
else:
from api.v1.app import auth
iD = user.id
create = auth.create_session(iD)
res = jsonify(user.to_json())
se_name = getenv('SESSION_NAME')
res.set_cookie(se_name, create)
return res
return jsonify({"error": "no user found for this email"}), 404
def login():
""" Method login, that create a new
view for Session Authentication
"""
email = request.form.get('email')
password = request.form.get('password')
if not email:
return jsonify({"error": "email missing"}), 400
if not password:
return jsonify({"error": "password missing"}), 400
try:
user = User.search({'email': email})
except Exception():
return jsonify({"error": "no user found for this email"}), 404
if not user:
return jsonify({"error": "no user found for this email"}), 404
for index in user:
if not index.is_valid_password(password):
return jsonify({"error": "wrong password"}), 401
else:
from api.v1.app import auth
session_user_id = index.id
new_session_id = auth.create_session(session_user_id)
json = jsonify(index.to_json())
session_name = getenv('SESSION_NAME')
json.set_cookie(session_name, new_session_id)
return json
def handle_all_routes():
"""POST: api/v1/auth_session/login/
"""
email = request.form.get('email')
if email is None or email == "":
return jsonify({"error": "email missing"}), 400
pwd = request.form.get('password')
if pwd is None or pwd == "":
return jsonify({"error": "password missing"}), 400
from models.user import User
try:
search_user = User.search({'email': email})
if search_user == []:
return jsonify({"error": "no user found for this email"}), 404
except Exception:
return None
for user in search_user:
if not user.is_valid_password(pwd):
return jsonify({"error": "wrong password"}), 401
from api.v1.app import auth
session_id = auth.create_session(search_user[0].id)
Name = getenv('SESSION_NAME')
result = jsonify(search_user[0].to_json())
result.set_cookie(Name, session_id)
return result
def login():
""" Send credentials and verify """
user_email = request.form.get('email')
if not user_email:
return jsonify({"error": "email missing"}), 400
user_pwd = request.form.get('password')
if not user_pwd:
return jsonify({"error": "password missing"}), 400
try:
search = User.search({"email": user_email})
except BaseException:
return jsonify({"error": "no user found for this email"}), 404
if not search:
return jsonify({"error": "no user found for this email"}), 404
for user in search:
if not user.is_valid_password(user_pwd):
return jsonify({"error": "wrong password"}), 401
from api.v1.app import auth
session_id = auth.create_session(user.id)
response = jsonify(user.to_json())
response.set_cookie(getenv('SESSION_NAME'), session_id)
return response
return jsonify({"error": "no user found for this email"}), 404
def login():
"""
send and check login data
"""
u_email = request.form.get('email')
if not u_email:
return jsonify({"error": "email missing"}), 400
u_pwd = request.form.get('password')
if not u_pwd:
return jsonify({"error": "password missing"}), 400
try:
users = User.search({"email": u_email})
except BaseException:
return jsonify({"error": "no user found for this email"}), 404
if not users:
return jsonify({"error": "no user found for this email"}), 404
for u in users:
if not u.is_valid_password(u_pwd):
return jsonify({"error": "wrong password"}), 401
from api.v1.app import auth
s_id = auth.create_session(u.id)
r = jsonify(u.to_json())
r.set_cookie(getenv('SESSION_NAME'), s_id)
return r
return jsonify({"error": "no user found for this email"}), 404
def login():
""" Auth session Login
Return:
Sessioned with credentials
"""
email = request.form.get('email')
if not email:
return make_response(jsonify({"error": "email missing"}), 400)
passwd = request.form.get('password')
if not passwd:
return make_response(jsonify({"error": "password missing"}), 400)
exist_user = User.search({"email": email})
if len(exist_user) == 0:
return jsonify({"error": "no user found for this email"}), 404
from api.v1.app import auth
for user in exist_user:
if (user.is_valid_password(passwd)):
session_id = auth.create_session(user.id)
SESSION_NAME = getenv('SESSION_NAME')
response = make_response(user.to_json())
response.set_cookie(SESSION_NAME, session_id)
return response
return make_response(jsonify({"error": "wrong password"}), 401)
def sessionLogin() -> str:
"""
handle for the Session authentication.
"""
email = request.form.get('email')
password = request.form.get('password')
if not email:
return jsonify({"error": "email missing"}), 400
if not password:
return jsonify({"error": "password missing"}), 400
try:
_user = User.search({'email': email})
except Exception:
_user = []
if len(_user) > 0:
valid_pass = _user[0].is_valid_password(password)
if not valid_pass:
return jsonify({"error": "wrong password"}), 401
from api.v1.app import auth
session_id = auth.create_session(_user[0].id)
_user_json = jsonify(_user[0].to_json())
_cookie = os.getenv('SESSION_NAME')
_user_json.set_cookie(_cookie, session_id)
return _user_json
else:
return jsonify({"error": "no user found for this email"}), 404
def login():
""" POST /auth_session/login
Return:
- Response - json string
"""
user_email = request.form.get('email')
user_pwd = request.form.get('password')
if not user_email:
return jsonify(error="email missing"), 400
if not user_pwd:
return jsonify(error="password missing"), 400
try:
user = User.search({"email": user_email})
except Exception:
return jsonify(error="no user found for this email"), 404
if not user:
return jsonify(error="no user found for this email"), 404
for u in user:
if u.is_valid_password(user_pwd):
user_id = u.id
from api.v1.app import auth
session_id = auth.create_session(user_id)
resp_json = jsonify(u.to_json())
resp_json.set_cookie(getenv('SESSION_NAME'), session_id)
return resp_json
else:
return jsonify(error="wrong password"), 401
return jsonify(error="no user found for this email"), 404
def session_auth_login() -> str:
""" POST /api/v1/auth_session/login
"""
email = request.form.get('email', None)
if email is None or not email:
return jsonify({"error": "email missing"}), 400
password = request.form.get('password', None)
if password is None or not password:
return jsonify({"error": "password missing"}), 400
user = User.search({'email': email})
if not user:
return jsonify({"error": "no user found for this email"}), 404
user = user[0]
valid_pw = user.is_valid_password(password)
if not valid_pw:
return jsonify({"error": "wrong password"}), 401
from api.v1.app import auth
sessionId = auth.create_session(user.id)
cookie_name = getenv('SESSION_NAME')
result = jsonify(user.to_json())
result.set_cookie(cookie_name, sessionId)
return result
def login():
""" GET /api/v1/users
Return:
- list of all User objects JSON represented
"""
email = request.form.get("email")
password = request.form.get("password")
if not email:
return jsonify({"error": "email missing"}), 400
if not password:
return jsonify({"error": "password missing"}), 400
users = User.search({"email": email})
if not users:
return jsonify(error="no user found for this email"), 404
for user in users:
if not user.is_valid_password(password):
return jsonify({"error": "wrong password"}), 401
else:
from api.v1.app import auth
sesion_id = auth.create_session(user.id)
sesion_name = os.getenv("SESSION_NAME")
user_dict = jsonify(user.to_json())
user_dict.set_cookie(sesion_name, sesion_id)
return user_dict
def auth_session_login():
""" POST /api/v1/auth_session/login
Return:
- User object JSON represented
- 400 if email or password is missing/empty
- 401 if password is incorrect
- 404 if no User is found for the provided email
"""
from api.v1.app import auth
user_email = request.form.get("email")
user_password = request.form.get("password")
if user_email is None or user_email == "":
return jsonify({"error": "email missing"}), 400
elif user_password is None or user_password == "":
return jsonify({"error": "password missing"}), 400
user_list = User.search({"email": user_email})
if len(user_list) == 0:
return jsonify({"error": "no user found for this email"}), 404
user = user_list[0]
if not user.is_valid_password(user_password):
return jsonify({"error": "wrong password"}), 401
session_id = auth.create_session(user.id)
cookie_name = os.getenv("SESSION_NAME")
response = make_response(user.to_json())
response.set_cookie(cookie_name, session_id)
return response
def session_login() -> str:
""" POST /api/v1/auth/session/login
JSON body:
- email
- password
Return:
- User instance based on email
- 400 if email or password is missing
"""
user_email = request.form.get('email', None)
user_password = request.form.get('password', None)
if user_email is None or user_email == "":
return jsonify({"error": "email missing"}), 400
if user_password is None or user_password == "":
return jsonify({"error": "password missing"}), 400
is_valid_user = User.search({'email': user_email})
if not is_valid_user:
return jsonify({"error": "no user found for this email"}), 404
is_valid_user = is_valid_user[0]
if not is_valid_user.is_valid_password(user_password):
return jsonify({"error": "wrong password"}), 401
from api.v1.app import auth
session_id = auth.create_session(is_valid_user.id)
cookie_response = getenv('SESSION_NAME')
user_dict = jsonify(is_valid_user.to_json())
user_dict.set_cookie(cookie_response, session_id)
return user_dict
def login() -> str:
""" POST /auth_session/login
Return:
- json string
"""
u_email = request.form.get('email')
if not u_email:
return jsonify({"error": "email missing"}), 400
u_password = request.form.get('password')
if not u_password:
return jsonify({"error": "password missing"}), 400
user = User.search({'email': u_email})
if not user:
return jsonify({"error": "no user found for this email"}), 404
for u in user:
if u.is_valid_password(u_password):
from api.v1.app import auth
session_id = auth.create_session(u.id)
user_json = jsonify(u.to_json())
user_json.set_cookie(os.getenv('SESSION_NAME'), session_id)
return user_json
else:
return jsonify({"error": "wrong password"}), 401
def login() -> Dict[str, str]:
"""
view for login form
:return: dict representation of User instance
"""
if request:
email = request.form.get('email', None)
if not email:
return jsonify({"error": "email missing"}), 400
password = request.form.get('password', None)
if not password:
return jsonify({"error": "password missing"}), 400
users_with_email: list[Union[User, None]] = \
User.search({'email': email})
if not users_with_email:
return jsonify({"error": "no user found for this email"}), 404
if not users_with_email[0].is_valid_password(password):
return jsonify({"error": "wrong password"}), 401
user = users_with_email[0]
from api.v1.app import auth
cookie_value = auth.create_session(user.id)
if cookie_value:
cookie_name = getenv('SESSION_NAME')
response = make_response(jsonify(user.to_json()), 200)
response.headers['Content-Type'] = 'application/json'
response.set_cookie(cookie_name, value=cookie_value)
return response
def login():
"""POST /auth_session/login """
email = request.form.get('email')
passwd = request.form.get('password')
if not email:
return jsonify({"error": "email missing"}), 400
if not passwd:
return jsonify({"error": "password missing"}), 400
try:
user = User.search({'email': email})
except Exception:
return jsonify({"error": "no user found for this email"}), 404
if not user:
return jsonify({"error": "no user found for this email"}), 404
for i in user:
if not i.is_valid_password(passwd):
return jsonify({"error": "wrong password"}), 401
else:
from api.v1.app import auth
user_id = i.id
session = auth.create_session(user_id)
res = jsonify(i.to_json())
name = os.getenv('SESSION_NAME')
res.set_cookie(name, session)
return res
def login_session():
"""POST method
Return: dictionary representation of the User
"""
from api.v1.app import auth
email = request.form.get("email")
pwd = request.form.get("password")
session_name = os.getenv("SESSION_NAME")
if not email or not len(email):
return jsonify({"error": "email missing"}), 400
if not pwd or not len(email):
return jsonify({"error": "password missing"}), 400
try:
users = User.search({"email": email})
except Exception:
users = None
if not users:
return jsonify({"error": "no user found for this email"}), 404
for user in users:
if user.is_valid_password(pwd):
try:
session_id = auth.create_session(user.id)
user_to_json = jsonify(user.to_json())
user_to_json.set_cookie(session_name, session_id)
except Exception:
break
return user_to_json
return jsonify({"error": "wrong password"}), 404
def login() -> str:
''' def login '''
email = request.form.get('email')
password = request.form.get('password')
if email is None:
return jsonify(error="email missing"), 400
if password is None:
return jsonify(error="password missing"), 400
user = User.search({"email": email})
if not user:
return jsonify(error="no user found for this email"), 404
if not user[0].is_valid_password(password):
return jsonify({"error": "wrong password"}), 401
from api.v1.app import auth
session = auth.create_session(user[0].id)
json = jsonify(user[0].to_json())
json.set_cookie(os.getenv('SESSION_NAME'), session)
return json
def login() -> str:
""" POST /api/v1/auth_session/login
"""
email = request.form.get("email")
if not email or email == '':
return jsonify({"error": "email missing"}), 400
password = request.form.get("password")
if not password or password == '':
return jsonify({"error": "password missing"}), 400
objs = User().search({"email": email})
if not objs or objs == []:
return jsonify({"error": "no user found for this email"}), 404
if not objs[0].is_valid_password(password):
return jsonify({"error": "wrong password"}), 401
from api.v1.app import auth
session_id = auth.create_session(objs[0].id)
result = jsonify(objs[0].to_json())
result.set_cookie(os.getenv("SESSION_NAME"), session_id)
return result
def login():
""" login route """
email = request.form.get('email')
if type(email) is not str or len(email) == 0:
return jsonify({"error": "email missing"}), 400
password = request.form.get('password')
if type(password) is not str or len(password) == 0:
return jsonify({"error": "password missing"}), 400
try:
user = db_session.query(User).filter(User.email == email).one()
if not user.is_valid_password(password):
return jsonify({'error': 'wrong password'}), 401
user = user.to_dict()
sess_id = auth.create_session(user['id'])
out = jsonify(user)
out.set_cookie(os.getenv('HBNB_YELP_SESSION_NAME'), sess_id)
return out, 200
except:
return jsonify({'error': 'no user found for this email'}), 404
def login():
"""[login]
"""
email = request.form.get('email')
pwd = request.form.get('password')
if not email or email == '':
return jsonify({"error": "email missing"}), 400
if not pwd or pwd == '':
return jsonify({"error": "password missing"}), 400
user = User.search({"email": email})
if not user:
return jsonify({"error": "no user found for this email"}), 404
if not user[0].is_valid_password(pwd):
return jsonify({"error": "wrong password"}), 401
else:
from api.v1.app import auth
session_user_id = auth.create_session(user[0].id)
response = jsonify(user[0].to_json())
response.set_cookie(os.getenv("SESSION_NAME"), session_user_id)
return response
def login():
""" Login session view
"""
email = request.form.get('email')
if not email:
return jsonify({'error': 'email missing'}), 400
password = request.form.get('password')
if not password:
return jsonify({'error': 'password missing'}), 400
users = User.search({'email': email})
if not users:
return jsonify({'error': 'no user found for this email'}), 404
current_user = users[0]
pwd_validation = current_user.is_valid_password(password)
if pwd_validation is False:
return jsonify({'error': 'wrong password'}), 401
else:
from api.v1.app import auth
session_id = auth.create_session(current_user.id)
response = jsonify(current_user.to_json())
response.set_cookie(getenv('SESSION_NAME'), str(session_id))
return response
def sessionLogin() -> str:
""" POST /api/v1/auth_session/login
Return:
- the status of the API
"""
email = request.form.get('email')
if not email:
return jsonify({"error": "email missing"}), 400
password = request.form.get('password')
if not password:
return jsonify({"error": "password missing"}), 400
users = User.search({'email': email})
if len(users) == 0:
return jsonify({"error": "no user found for this email"}), 404
for item in users:
if item.is_valid_password(password):
from api.v1.app import auth
resp = jsonify(item.to_json())
SESSION_NAME = getenv('SESSION_NAME')
resp.set_cookie(SESSION_NAME, auth.create_session(item.id))
return resp
return jsonify({"error": "wrong password"}), 401
def login():
""" Handles all routes for the Session authentication
"""
email = request.form.get('email')
pwd = request.form.get('password')
if not email:
return jsonify(error="email missing"), 400
if not pwd:
return jsonify(error="password missing"), 400
users = User.search({"email": email})
if not users:
return jsonify(error="no user found for this email"), 404
for user in users:
if user.is_valid_password(pwd):
from api.v1.app import auth
session = auth.create_session(user.id)
json = jsonify(user.to_json())
json.set_cookie(getenv('SESSION_NAME'), session)
return json
else:
return jsonify(error="wrong password"), 401
