def create_user(self, user: schemas.UserCreate) -> Any:
""" Add New User"""
try:
with session_scope() as db:
hashed_password = passutil.get_password_hash(str(
user.password))
db_user = models.User(
email=user.email,
password=hashed_password,
first_name=user.first_name,
last_name=user.last_name,
full_name=user.full_name,
gender=user.gender,
is_active=user.is_active,
is_superuser=user.is_superuser,
is_admin=user.is_admin,
created_by_userid=user.created_by_userid,
modified_by_userid=user.created_by_userid)
db.add(db_user)
db.commit()
db.refresh(db_user)
return db_user
except SQLAlchemyError as e:
fastapi_logger.exception("create_user")
return None
def update_user(self, user_id: int, user: schemas.UserUpdate) -> Any:
""" Update User"""
try:
with session_scope() as db:
statement = select(
models.User).where(models.User.id == user_id)
results = db.exec(statement)
db_user = results.one()
db_user.first_name = user.first_name
db_user.last_name = user.last_name
db_user.full_name = user.full_name
db_user.city = user.city
db_user.country = user.country
db_user.is_active = user.is_active
db_user.is_superuser = user.is_superuser
db_user.is_admin = user.is_admin
db_user.modified_by_userid = user.modified_by_userid
db_user.modified_timestamp = datetime.utcnow()
db.add(db_user)
db.commit()
db.refresh(db_user)
return db_user
except SQLAlchemyError as e:
fastapi_logger.exception("update_user")
return None
def get_user_password(email: str) -> Any:
""" Get User Password based on email"""
try:
with session_scope() as db:
statement = select(models.User).where(models.User.email == email)
results = db.exec(statement)
data = results.one()
return data
except SQLAlchemyError as e:
fastapi_logger.exception("get_user")
return None
def get_user_id(self, id: int) -> Any:
""" Get User Data based on id"""
try:
with session_scope() as db:
statement = select(models.User).where(
models.User.id == id).options(defer('password'))
results = db.exec(statement)
data = results.one()
return data
except SQLAlchemyError as e:
fastapi_logger.exception("get_user_id")
return None
def get_article(self, article_id: str):
""" Get A Single article """
try:
with session_scope() as db:
statement = select(models.Article).where(
models.Article.article_id == article_id)
results = db.exec(statement)
data = results.one()
return data
except SQLAlchemyError as e:
fastapi_logger.exception("get_article")
return None
def check_active_session(self, session_id: str):
""" check for active session """
try:
with session_scope() as db:
statement = select(models.UsersLoginAttempt).where(
models.UsersLoginAttempt.session_id == session_id)
results = db.exec(statement)
data = results.one()
return data
except SQLAlchemyError as e:
fastapi_logger.exception("check_active_session")
return None
def verify_user(self, email: str) -> Any:
""" Verify User"""
try:
with session_scope() as db:
statement = select(
models.User.id,
models.User.email).where(models.User.email == email)
results = db.exec(statement)
data = results.one()
return data
except SQLAlchemyError as e:
fastapi_logger.exception("verify_user")
return None
def check_password(self, user_id: int, password: str):
""" get user Password"""
try:
with session_scope() as db:
statement = select(
models.User.password).where(models.User.id == user_id)
results = db.exec(statement)
db_user = results.one()
return passutil.verify_password(str(password),
str(db_user.password))
except SQLAlchemyError as e:
fastapi_logger.exception("get_password")
return None
def delete_user(self, user_id: int) -> Any:
""" Delete User"""
try:
with session_scope() as db:
statement = select(
models.User).where(models.User.id == user_id)
results = db.exec(statement)
db_user = results.one()
db.delete(db_user)
db.commit()
return True
except SQLAlchemyError as e:
fastapi_logger.exception("delete_user")
return None
def get_active_user(email: str) -> Any:
""" Get User Data based on email and active status"""
try:
with session_scope() as db:
statement = select(
models.User).where(models.User.email == email).where(
models.User.is_active == expression.true()).options(
defer('password'))
results = db.exec(statement)
data = results.one()
return data
except SQLAlchemyError as e:
fastapi_logger.exception("get_user")
return None
def get_all_articles(self, page_num: int) -> Any:
""" Get All Articles """
try:
with session_scope() as db:
query = select(models.Article).order_by(
models.Article.modified_timestamp)
data = pagination.paginate(query=query, db=db,
model=models.Article, page=page_num,
page_size=30)
return data
except SQLAlchemyError as e:
fastapi_logger.exception("get_all_articles")
return None
def delete_article(self, article_id: str) -> Any:
""" Delete Article """
try:
with session_scope() as db:
statement = select(models.Article).where(
models.Article.article_id == article_id)
results = db.exec(statement)
db_article = results.one()
db.delete(db_article)
db.commit()
return True
except SQLAlchemyError as e:
fastapi_logger.exception("delete_article")
return None
def get_all_user(self, page_num: int) -> Any:
""" Get All Users"""
try:
with session_scope() as db:
# data = db.query(models.User).options(defer('password')).all()
statement = select(models.User).options(
defer('password')).order_by(models.User.modified_timestamp)
data = pagination.paginate(query=statement,
db=db,
model=models.User,
page=page_num,
page_size=100)
return data
except SQLAlchemyError as e:
fastapi_logger.exception("get_all_user")
return None
def update_user_password(self, email: str, password: str) -> Any:
""" Update User Password"""
try:
with session_scope() as db:
hashed_password = passutil.get_password_hash(password)
statement = select(
models.User).where(models.User.email == email)
results = db.exec(statement)
db_user = results.one()
db_user.password = hashed_password
db.commit()
db.refresh(db_user)
return db_user
except SQLAlchemyError as e:
fastapi_logger.exception("update_user_password")
return None
def login_user(self, user: schemas.UserLogIn, session_id: str) -> Any:
""" Login Attempt Record """
try:
with session_scope() as db:
db_session = models.UsersLoginAttempt(
email=user.email,
session_id=session_id,
ip_address=user.ip_address,
browser=user.browser,
status="logged_in")
db.add(db_session)
db.commit()
db.refresh(db_session)
return db_session
except SQLAlchemyError as e:
fastapi_logger.exception("login_user")
return None
def create_article(self, article: schemas.ArticleCreate) -> Any:
""" Create New Article """
try:
with session_scope() as db:
uid = str(uuid.uuid4().hex)
db_user = models.Article(article_id=uid,
user_id=article.user_id,
article_title=article.article_title,
article_text=article.article_text,
tags=article.tags)
db.add(db_user)
db.commit()
db.refresh(db_user)
return db_user
except SQLAlchemyError as e:
fastapi_logger.exception("create_article")
return None
def logoff_user(self, session_id: str) -> Any:
""" Logging off Record"""
try:
with session_scope() as db:
statement = select(models.UsersLoginAttempt).where(
models.UsersLoginAttempt.session_id == session_id)
results = db.exec(statement)
db_session = results.one()
db_session.status = "logged_off"
db.add(db_session)
db.commit()
db.refresh(db_session)
return db_session
except SQLAlchemyError as e:
fastapi_logger.exception("logoff_user")
return None
def user_status_update(self, user_id: int, status: str) -> Any:
""" Disable User"""
try:
with session_scope() as db:
statement = select(
models.User).where(models.User.id == user_id)
results = db.exec(statement)
db_user = results.one()
if status == "enable":
db_user.is_active = True
elif status == "disable":
db_user.is_active = False
db.add(db_user)
db.commit()
db.refresh(db_user)
return db_user
except SQLAlchemyError as e:
fastapi_logger.exception("user_status_update")
return None
def update_article(self, article_id: str,
article: schemas.ArticleCreate) -> Any:
""" Update Article """
try:
with session_scope() as db:
statement = select(models.Article).where(
models.Article.article_id == article_id)
results = db.exec(statement)
db_article = results.one()
db_article.article_title = article.article_title
db_article.article_text = article.article_text
db_article.tags = article.tags
db_article.modified_timestamp = datetime.utcnow()
db.commit()
db.refresh(db_article)
return db_article
except SQLAlchemyError as e:
fastapi_logger.exception("update_article")
return None
def get_current_user(token: str = Depends(oauth2_scheme),
db: Session = Depends(session_scope)) -> UserVerify:
""" Verify User Authentication"""
credentials_exception = HTTPException(
status_code=status.HTTP_401_UNAUTHORIZED,
detail="Could not validate credentials",
headers={"WWW-Authenticate": "Bearer"},
)
expire_exception = HTTPException(
status_code=status.HTTP_401_UNAUTHORIZED,
detail="access expired",
headers={"WWW-Authenticate": "Bearer"},
)
require_exception = HTTPException(
status_code=status.HTTP_401_UNAUTHORIZED,
detail="access denied",
headers={"WWW-Authenticate": "Bearer"},
)
if token:
try:
payload = access_token.decode_access_token(token=token)
token_validity = payload.get("exp")
if get_int_from_datetime(datetime.utcnow()) >= token_validity:
raise expire_exception
email: str = payload.get("sub")
if email is None:
raise credentials_exception
token_data = TokenData(email=email)
except exceptions.JWTException as e:
fastapi_logger.exception("get_current_user")
raise credentials_exception
user = crud_users.verify_user(email=token_data.email)
if user is None:
raise credentials_exception
return user
else:
raise require_exception