Merge pull request #26 from exactpro/release-8.1.0

Release 8.1.0

.env

@@ -20,4 +20,6 @@ POSTGRES_USER=postgres_user
 POSTGRES_PASSWORD=postgres_password
 POSTGRES_DB=users
 POSTGRES_HOST=postgresql
-POSTGRES_PORT=5432
+POSTGRES_PORT=5432
+
+SENTRY_DSN=

.pre-commit-config.yaml

@@ -3,6 +3,6 @@ repos:
  rev: stable
  hooks:
  - id: black
- language_version: python3.7
+ language_version: python3.8
 
 default_stages: [commit, push]

README.md

@@ -14,7 +14,7 @@ Nostradamus also calculates various statistical data including distributions and
 * a list of the most frequently used terms;
 * a list of the most significant words, etc.
 
-This knowledge further allows to achieve various IT-related goals, e.g.:
+This knowledge further allows achieving various IT-related goals, e.g.:
 * 📝 More accurate planning and goal setting for Project Managers;
 * 📈 Improving the defect report quality for QA Engineers and Junior Analysts;
 * 🔎 Discovering the dependencies hidden in development, for system architects and developers.

auth/Dockerfile

@@ -0,0 +1,16 @@
+FROM python:3.8-slim
+
+WORKDIR /app
+
+USER root
+
+RUN apt-get -y update && apt-get install -y libpq-dev gcc \
+ && pip install --upgrade pip
+
+RUN pip3 install poetry==1.1.4
+
+COPY poetry.lock pyproject.toml /app/
+
+RUN poetry install --no-dev
+
+COPY . /app/

auth/authentication/register.py

@@ -0,0 +1,30 @@
+from passlib.context import CryptContext
+
+from models.User import User
+from models.UserSettings import UserSettings
+from models.UserFilter import UserFilter
+from models.UserQAMetricsFilter import UserQAMetricsFilter
+from models.UserPredictionsTable import UserPredictionsTable
+
+from serializers import UserSerializer
+
+from settings.settings import init_filters, init_predictions_table
+
+
+async def create_user(user: UserSerializer) -> None:
+ """Creates a new User with default settings.
+
+ :param user: New user.
+ """
+ user = user.dict()
+ user["password"] = CryptContext(schemes=["sha256_crypt"]).hash(
+ user["password"]
+ )
+ user["email"] = user["email"].lower().strip()
+ user["name"] = user["name"].strip()
+ user = await User(**user).create()
+ user_settings = await UserSettings(user_id=user.id).create()
+
+ await init_filters(UserFilter, user_settings.id)
+ await init_filters(UserQAMetricsFilter, user_settings.id)
+ await init_predictions_table(UserPredictionsTable, user_settings.id)

auth/authentication/sign_in.py

@@ -0,0 +1,59 @@
+import json
+from typing import Dict, Union
+
+
+from fastapi import HTTPException
+from passlib.context import CryptContext
+
+from authentication.token import create_token
+from models.User import User
+
+from serializers import UserCredentialsSerializer
+from database import create_session
+
+
+DEFAULT_ERROR_CODE = 500
+
+
+def auth_user(
+ user_data: UserCredentialsSerializer,
+) -> Dict[str, Union[str, int]]:
+ """Authenticates User.
+
+ :param user_data: User credentials.
+ :return: Authenticated User with JWT.
+ """
+ with create_session() as db:
+ user = (
+ db.query(User)
+ .filter(User.email == user_data.credentials.lower().strip())
+ .first()
+ )
+ if not user:
+ user = (
+ db.query(User)
+ .filter(
+ User.name == user_data.credentials.strip(),
+ )
+ .first()
+ )
+ if not user:
+ raise HTTPException(
+ status_code=DEFAULT_ERROR_CODE,
+ detail="Incorrect username or password.",
+ )
+ if not CryptContext(schemes=["sha256_crypt"]).verify(
+ user_data.password, user.password
+ ):
+ raise HTTPException(
+ status_code=DEFAULT_ERROR_CODE,
+ detail="Incorrect username or password.",
+ )
+
+ response = {
+ "id": str(user.id),
+ "name": user.name,
+ "email": user.email,
+ "token": create_token(user),
+ }
+ return response

auth/authentication/token.py

@@ -0,0 +1,52 @@
+import os
+
+import jwt
+from datetime import datetime, timedelta
+from fastapi import HTTPException
+
+from database import create_session
+from models.User import User
+
+ACCESS_TOKEN_EXPIRE_WEEKS = 15
+
+SECRET_KEY_DEFAULT = "v$1bx=+6#ibt4a$4i&5i8stwjqzm+3=tjsde9iku1a0w(u6bfy"
+SECRET_KEY = os.environ.get("SECRET_KEY", default=SECRET_KEY_DEFAULT)
+
+
+def create_token(user: User) -> str:
+ """Generates JSON Web Token.
+
+ :param user: User to be authenticated.
+ :return: JSON Web Token.
+ """
+ raw_token = {
+ "exp": datetime.utcnow() + timedelta(weeks=ACCESS_TOKEN_EXPIRE_WEEKS),
+ "id": str(user.id),
+ }
+ token = jwt.encode(raw_token, key=SECRET_KEY).decode("UTF-8")
+ return token
+
+
+def decode_jwt(token: str) -> str:
+ """Checks JSON Web Token and return user id.
+
+ :param token: JSON Web Token.
+ :return: User id.
+ """
+ # To avoid a circular dependency
+ from authentication.sign_in import DEFAULT_ERROR_CODE
+
+ try:
+ decoded_token = jwt.decode(jwt=token, key=SECRET_KEY)
+ except jwt.DecodeError:
+ raise HTTPException(status_code=DEFAULT_ERROR_CODE, detail="Token is invalid")
+ except jwt.ExpiredSignatureError:
+ raise HTTPException(status_code=DEFAULT_ERROR_CODE, detail="Token expired")
+ with create_session() as db:
+ user = db.query(User).filter(User.id == decoded_token.get("id")).first()
+
+ if not user:
+ raise HTTPException(
+ status_code=DEFAULT_ERROR_CODE, detail="User not found",
+ )
+ return str(user.id)

auth/database.py

@@ -0,0 +1,32 @@
+import os
+from contextlib import contextmanager
+
+from sqlalchemy import create_engine
+from sqlalchemy.ext.declarative import declarative_base
+from sqlalchemy.orm import sessionmaker, Session
+
+
+DB_NAME = os.environ.get("POSTGRES_DB", "users")
+DB_USER = os.environ.get("POSTGRES_USER", "postgres_user")
+DB_PASSWORD = os.environ.get("POSTGRES_PASSWORD", "postgres_password")
+DB_HOST = os.environ.get("POSTGRES_HOST", "localhost")
+DB_PORT = os.environ.get("POSTGRES_PORT", "5432")
+DB_URL = f"postgresql://{DB_USER}:{DB_PASSWORD}@{DB_HOST}:{DB_PORT}/{DB_NAME}"
+
+engine = create_engine(DB_URL)
+SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+
+Base = declarative_base()
+
+
+@contextmanager
+def create_session() -> Session:
+ """Create database session.
+
+ :return: Database session.
+ """
+ session = SessionLocal()
+ try:
+ yield session
+ finally:
+ session.close()

auth/main.py

@@ -0,0 +1,69 @@
+from fastapi import FastAPI
+from fastapi.encoders import jsonable_encoder
+from fastapi.exceptions import RequestValidationError, HTTPException
+from fastapi.responses import JSONResponse
+from starlette.requests import Request
+from starlette.responses import Response
+
+from authentication.token import decode_jwt
+from authentication.sign_in import auth_user
+from authentication.register import create_user
+
+from database import engine, Base
+
+from serializers import (
+ UserSerializer,
+ UserCredentialsSerializer,
+ AuthResponseSerializer,
+ VerifyTokenResponse,
+)
+
+
+TABLES_TO_CREATE = (
+ Base.metadata.tables["users"],
+ Base.metadata.tables["user_settings"],
+ Base.metadata.tables["user_filter"],
+ Base.metadata.tables["user_qa_metrics_filter"],
+ Base.metadata.tables["user_predictions_table"],
+)
+
+Base.metadata.create_all(bind=engine, tables=TABLES_TO_CREATE)
+
+app = FastAPI()
+
+
+@app.exception_handler(HTTPException)
+async def http_exception_handler(request, exc):
+ return JSONResponse(
+ content={"exception": {"detail": exc.detail}}, status_code=exc.status_code,
+ )
+
+
+@app.exception_handler(RequestValidationError)
+async def validation_exception_handler(request: Request, exc: RequestValidationError):
+ exception_detail = [
+ {"name": error.get("loc")[1], "errors": [error.get("msg")]}
+ for error in exc.errors()
+ ]
+
+ return JSONResponse(
+ status_code=400, content=jsonable_encoder({"exception": exception_detail}),
+ )
+
+
+@app.post("/sign_in/", response_model=AuthResponseSerializer)
+def sign_in(user: UserCredentialsSerializer):
+ user = auth_user(user)
+ return JSONResponse(user)
+
+
+@app.post("/register/")
+async def register(user: UserSerializer):
+ await create_user(user)
+ return Response(status_code=200)
+
+
+@app.get("/verify_token/", response_model=VerifyTokenResponse)
+def verify_token(token: str):
+ response = {"id": decode_jwt(token)}
+ return JSONResponse(response)

auth/models/User.py

@@ -0,0 +1,37 @@
+from sqlalchemy import Column, String, Integer
+from sqlalchemy.orm import relationship
+
+from database import Base, create_session
+
+
+class User(Base):
+ __tablename__ = "users"
+
+ id = Column(
+ Integer, primary_key=True, index=True, unique=True, autoincrement=True
+ )
+ email = Column(String, unique=True)
+ name = Column(
+ String,
+ unique=True,
+ )
+ password = Column(String)
+
+ user_settings = relationship(
+ "UserSettings",
+ uselist=False,
+ back_populates="user",
+ cascade="all, delete, delete-orphan",
+ )
+
+ def __repr__(self):
+ return (
+ f"<User(id='{self.id}', email='{self.email}', name='{self.name}')>"
+ )
+
+ async def create(self):
+ with create_session() as db:
+ db.add(self)
+ db.commit()
+ db.refresh(self)
+ return self

auth/models/UserFilter.py

@@ -0,0 +1,32 @@
+from sqlalchemy import Column, ForeignKey, String, Integer
+from sqlalchemy.orm import relationship
+
+from database import Base, create_session
+
+
+class UserFilter(Base):
+ __tablename__ = "user_filter"
+
+ id = Column(
+ Integer, primary_key=True, index=True, unique=True, autoincrement=True
+ )
+ settings_id = Column(
+ Integer, ForeignKey("user_settings.id", ondelete="CASCADE")
+ )
+ name = Column(String)
+ type = Column(String)
+
+ user_settings = relationship("UserSettings", back_populates="user_filter")
+
+ def __repr__(self):
+ return (
+ f"<UserFilter(id='{self.id}', name='{self.name}', "
+ f"type='{self.type}', settings_id='{self.settings_id}')>"
+ )
+
+ async def create(self):
+ with create_session() as db:
+ db.add(self)
+ db.commit()
+ db.refresh(self)
+ return self

auth/models/UserPredictionsTable.py

@@ -0,0 +1,36 @@
+from sqlalchemy import Column, ForeignKey, Integer, String, Boolean
+from sqlalchemy.orm import relationship
+
+from database import Base, create_session
+
+
+class UserPredictionsTable(Base):
+ __tablename__ = "user_predictions_table"
+
+ id = Column(
+ Integer, primary_key=True, index=True, unique=True, autoincrement=True
+ )
+ settings_id = Column(
+ Integer, ForeignKey("user_settings.id", ondelete="CASCADE")
+ )
+ name = Column(String)
+ is_default = Column(Boolean)
+ position = Column(Integer)
+
+ user_settings = relationship(
+ "UserSettings", back_populates="user_predictions_table"
+ )
+
+ def __repr__(self):
+ return (
+ f"<UserPredictionsTable(id='{self.id}', name='{self.name}', "
+ f"is_default='{self.is_default}', position='{self.position}', "
+ f"settings_id='{self.settings_id}')>"
+ )
+
+ async def create(self):
+ with create_session() as db:
+ db.add(self)
+ db.commit()
+ db.refresh(self)
+ return self